Ecosystem/xmrig
Ecosystem/xmrig
1
0
Fork 0
mirror of https://github.com/xmrig/xmrig.git synced 2024-11-17 00:07:44 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Move selfTest to threads, remove legacy CryptoNight.cpp.

Browse source
This commit is contained in:
XMRig 2018-04-03 14:51:05 +07:00
parent d7c5630509
commit 5c6ec587ac
11 changed files with 85 additions and 218 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
CMakeLists.txt
View file

@ -126,7 +126,6 @@ set(SOURCES_CRYPTO
src/crypto/c_blake256.c
src/crypto/c_jh.c
src/crypto/c_skein.c
src/crypto/CryptoNight.cpp
)
if (WIN32)

5
src/App.cpp
View file

@ -101,11 +101,6 @@ int App::exec()
background();
if (!CryptoNight::init(m_controller->config()->algorithm(), m_controller->config()->algoVariant(), m_controller->config()->isDoubleHash())) {
LOG_ERR("\"%s\" hash self-test failed.", m_controller->config()->algoName());
return 1;
}
Mem::allocate(m_controller->config()->algorithm(),
m_controller->config()->threadsCount(),
m_controller->config()->isDoubleHash(),

189
src/crypto/CryptoNight.cpp
View file

@ -1,189 +0,0 @@
/* XMRig
* Copyright 2010 Jeff Garzik <jgarzik@pobox.com>
* Copyright 2012-2014 pooler <pooler@litecoinpool.org>
* Copyright 2014 Lucas Jones <https://github.com/lucasjones>
* Copyright 2014-2016 Wolf9466 <https://github.com/OhGodAPet>
* Copyright 2016 Jay D Dee <jayddee246@gmail.com>
* Copyright 2017-2018 XMR-Stak <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
* Copyright 2018 Lee Clagett <https://github.com/vtnerd>
* Copyright 2016-2018 XMRig <https://github.com/xmrig>, <support@xmrig.com>
*
* 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 <http://www.gnu.org/licenses/>.
*/
#include "crypto/CryptoNight.h"
#if defined(XMRIG_ARM)
# include "crypto/CryptoNight_arm.h"
#else
# include "crypto/CryptoNight_x86.h"
#endif
#include "crypto/CryptoNight_test.h"
#include "net/Job.h"
#include "net/JobResult.h"
#include "xmrig.h"
void (*cryptonight_hash_ctx)(const uint8_t *input, size_t size, uint8_t *output, cryptonight_ctx *ctx, int variant) = nullptr;
#define CRYPTONIGHT_HASH(NAME, ALGO, SOFT_AES) \
switch (variant) { \
case xmrig::VARIANT_V1: \
return cryptonight_##NAME##_hash<ALGO, SOFT_AES, xmrig::VARIANT_V1>(input, size, output, ctx); \
\
case xmrig::VARIANT_NONE: \
return cryptonight_##NAME##_hash<ALGO, SOFT_AES, xmrig::VARIANT_NONE>(input, size, output, ctx); \
\
default: \
break; \
}
static void cryptonight_av1_aesni(const uint8_t *input, size_t size, uint8_t *output, struct cryptonight_ctx *ctx, int variant) {
# if !defined(XMRIG_ARMv7)
CRYPTONIGHT_HASH(single, xmrig::CRYPTONIGHT, false)
# endif
}
static void cryptonight_av2_aesni_double(const uint8_t *input, size_t size, uint8_t *output, cryptonight_ctx *ctx, int variant) {
# if !defined(XMRIG_ARMv7)
CRYPTONIGHT_HASH(double, xmrig::CRYPTONIGHT, false)
# endif
}
static void cryptonight_av3_softaes(const uint8_t *input, size_t size, uint8_t *output, cryptonight_ctx *ctx, int variant) {
CRYPTONIGHT_HASH(single, xmrig::CRYPTONIGHT, true)
}
static void cryptonight_av4_softaes_double(const uint8_t *input, size_t size, uint8_t *output, cryptonight_ctx *ctx, int variant) {
CRYPTONIGHT_HASH(double, xmrig::CRYPTONIGHT, true)
}
#ifndef XMRIG_NO_AEON
static void cryptonight_lite_av1_aesni(const uint8_t *input, size_t size, uint8_t *output, cryptonight_ctx *ctx, int variant) {
# if !defined(XMRIG_ARMv7)
CRYPTONIGHT_HASH(single, xmrig::CRYPTONIGHT_LITE, false)
# endif
}
static void cryptonight_lite_av2_aesni_double(const uint8_t *input, size_t size, uint8_t *output, cryptonight_ctx *ctx, int variant) {
# if !defined(XMRIG_ARMv7)
CRYPTONIGHT_HASH(double, xmrig::CRYPTONIGHT_LITE, false)
# endif
}
static void cryptonight_lite_av3_softaes(const uint8_t *input, size_t size, uint8_t *output, cryptonight_ctx *ctx, int variant) {
CRYPTONIGHT_HASH(single, xmrig::CRYPTONIGHT_LITE, true)
}
static void cryptonight_lite_av4_softaes_double(const uint8_t *input, size_t size, uint8_t *output, cryptonight_ctx *ctx, int variant) {
CRYPTONIGHT_HASH(double, xmrig::CRYPTONIGHT_LITE, true)
}
void (*cryptonight_variations[8])(const uint8_t *input, size_t size, uint8_t *output, cryptonight_ctx *ctx, int variant) = {
cryptonight_av1_aesni,
cryptonight_av2_aesni_double,
cryptonight_av3_softaes,
cryptonight_av4_softaes_double,
cryptonight_lite_av1_aesni,
cryptonight_lite_av2_aesni_double,
cryptonight_lite_av3_softaes,
cryptonight_lite_av4_softaes_double
};
#else
void (*cryptonight_variations[4])(const uint8_t *input, size_t size, uint8_t *output, cryptonight_ctx *ctx, int variant) = {
cryptonight_av1_aesni,
cryptonight_av2_aesni_double,
cryptonight_av3_softaes,
cryptonight_av4_softaes_double
};
#endif
bool CryptoNight::hash(const Job &job, JobResult &result, cryptonight_ctx *ctx)
{
cryptonight_hash_ctx(job.blob(), job.size(), result.result, ctx, job.variant());
return *reinterpret_cast<uint64_t*>(result.result + 24) < job.target();
}
bool CryptoNight::init(int algo, int variant, bool doubleHash)
{
if (variant < 1 || variant > 4) {
return false;
}
# ifndef XMRIG_NO_AEON
const int index = algo == xmrig::CRYPTONIGHT_LITE ? (variant + 3) : (variant - 1);
# else
const int index = variant - 1;
# endif
cryptonight_hash_ctx = cryptonight_variations[index];
return selfTest(algo, doubleHash);
}
void CryptoNight::hash(const uint8_t *input, size_t size, uint8_t *output, cryptonight_ctx *ctx, int variant)
{
cryptonight_hash_ctx(input, size, output, ctx, variant);
}
bool CryptoNight::selfTest(int algo, bool doubleHash) {
if (cryptonight_hash_ctx == nullptr) {
return false;
}
uint8_t output[64];
struct cryptonight_ctx *ctx = static_cast<cryptonight_ctx *>(_mm_malloc(sizeof(cryptonight_ctx), 16));
ctx->memory = static_cast<uint8_t *>(_mm_malloc(MONERO_MEMORY * 2, 16));
cryptonight_hash_ctx(test_input, 76, output, ctx, 0);
# ifndef XMRIG_NO_AEON
bool rc = memcmp(output, algo == xmrig::CRYPTONIGHT_LITE ? test_output_v0_lite : test_output_v0, (doubleHash ? 64 : 32)) == 0;
# else
bool rc = memcmp(output, test_output_v0, (doubleHash ? 64 : 32)) == 0;
# endif
if (rc) {
cryptonight_hash_ctx(test_input, 76, output, ctx, 1);
# ifndef XMRIG_NO_AEON
rc = memcmp(output, algo == xmrig::CRYPTONIGHT_LITE ? test_output_v1_lite : test_output_v1, (doubleHash ? 64 : 32)) == 0;
# else
rc = memcmp(output, test_output_v1, (doubleHash ? 64 : 32)) == 0;
# endif
}
_mm_free(ctx->memory);
_mm_free(ctx);
return rc;
}

15
src/crypto/CryptoNight.h
View file

@ -46,19 +46,4 @@ struct cryptonight_ctx {
};
class Job;
class JobResult;
class CryptoNight
{
public:
static bool hash(const Job &job, JobResult &result, cryptonight_ctx *ctx);
static bool init(int algo, int variant, bool doubleHash);
static void hash(const uint8_t *input, size_t size, uint8_t *output, cryptonight_ctx *ctx, int variant);
private:
static bool selfTest(int algo, bool doubleHash);
};
#endif /* __CRYPTONIGHT_H__ */

7
src/interfaces/IWorker.h
View file

@ -4,8 +4,8 @@
* Copyright 2014 Lucas Jones <https://github.com/lucasjones>
* Copyright 2014-2016 Wolf9466 <https://github.com/OhGodAPet>
* Copyright 2016 Jay D Dee <jayddee246@gmail.com>
* Copyright 2016-2017 XMRig <support@xmrig.com>
*
* Copyright 2017-2018 XMR-Stak <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
* Copyright 2016-2018 XMRig <https://github.com/xmrig>, <support@xmrig.com>
*
* 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
@ -33,9 +33,10 @@ class IWorker
public:
virtual ~IWorker() {}
virtual bool start() = 0;
virtual size_t id() const = 0;
virtual uint64_t hashCount() const = 0;
virtual uint64_t timestamp() const = 0;
virtual void start() = 0;
};

35
src/workers/DoubleWorker.cpp
View file

@ -26,6 +26,7 @@
#include <thread>
#include "crypto/CryptoNight_test.h"
#include "workers/CpuThread.h"
#include "workers/DoubleWorker.h"
#include "workers/Workers.h"
@ -61,8 +62,12 @@ DoubleWorker::~DoubleWorker()
}
void DoubleWorker::start()
bool DoubleWorker::start()
{
if (!selfTest()) {
return false;
}
while (Workers::sequence() > 0) {
if (Workers::isPaused()) {
do {
@ -101,6 +106,8 @@ void DoubleWorker::start()
consumeJob();
}
return true;
}
@ -115,6 +122,32 @@ bool DoubleWorker::resume(const Job &job)
}
bool DoubleWorker::selfTest()
{
if (m_thread->fn(xmrig::VARIANT_NONE) == nullptr) {
return false;
}
m_thread->fn(xmrig::VARIANT_NONE)(test_input, 76, m_hash, m_ctx);
if (m_thread->algorithm() == xmrig::CRYPTONIGHT && memcmp(m_hash, test_output_v0, 64) == 0) {
m_thread->fn(xmrig::VARIANT_V1)(test_input, 76, m_hash, m_ctx);
return memcmp(m_hash, test_output_v1, 64) == 0;
}
# ifndef XMRIG_NO_AEON
if (m_thread->algorithm() == xmrig::CRYPTONIGHT_LITE && memcmp(m_hash, test_output_v0_lite, 64) == 0) {
m_thread->fn(xmrig::VARIANT_V1)(test_input, 76, m_hash, m_ctx);
return memcmp(m_hash, test_output_v1_lite, 64) == 0;
}
# endif
return false;
}
void DoubleWorker::consumeJob()
{
Job job = Workers::job();

3
src/workers/DoubleWorker.h
View file

@ -40,10 +40,11 @@ public:
DoubleWorker(Handle *handle);
~DoubleWorker();
void start() override;
bool start() override;
private:
bool resume(const Job &job);
bool selfTest();
void consumeJob();
void save(const Job &job);

35
src/workers/SingleWorker.cpp
View file

@ -26,6 +26,7 @@
#include <thread>
#include "crypto/CryptoNight_test.h"
#include "workers/CpuThread.h"
#include "workers/SingleWorker.h"
#include "workers/Workers.h"
@ -37,8 +38,12 @@ SingleWorker::SingleWorker(Handle *handle)
}
void SingleWorker::start()
bool SingleWorker::start()
{
if (!selfTest()) {
return false;
}
while (Workers::sequence() > 0) {
if (Workers::isPaused()) {
do {
@ -71,6 +76,8 @@ void SingleWorker::start()
consumeJob();
}
return true;
}
@ -87,6 +94,32 @@ bool SingleWorker::resume(const Job &job)
}
bool SingleWorker::selfTest()
{
if (m_thread->fn(xmrig::VARIANT_NONE) == nullptr) {
return false;
}
m_thread->fn(xmrig::VARIANT_NONE)(test_input, 76, m_result.result, m_ctx);
if (m_thread->algorithm() == xmrig::CRYPTONIGHT && memcmp(m_result.result, test_output_v0, 32) == 0) {
m_thread->fn(xmrig::VARIANT_V1)(test_input, 76, m_result.result, m_ctx);
return memcmp(m_result.result, test_output_v1, 32) == 0;
}
# ifndef XMRIG_NO_AEON
if (m_thread->algorithm() == xmrig::CRYPTONIGHT_LITE && memcmp(m_result.result, test_output_v0_lite, 32) == 0) {
m_thread->fn(xmrig::VARIANT_V1)(test_input, 76, m_result.result, m_ctx);
return memcmp(m_result.result, test_output_v1_lite, 32) == 0;
}
# endif
return false;
}
void SingleWorker::consumeJob()
{
Job job = Workers::job();

3
src/workers/SingleWorker.h
View file

@ -39,10 +39,11 @@ class SingleWorker : public Worker
public:
SingleWorker(Handle *handle);
void start() override;
bool start() override;
private:
bool resume(const Job &job);
bool selfTest();
void consumeJob();
void save(const Job &job);

1
src/workers/Worker.h
View file

@ -47,6 +47,7 @@ public:
Worker(Handle *handle);
~Worker();
inline size_t id() const override { return m_id; }
inline uint64_t hashCount() const override { return m_hashCount.load(std::memory_order_relaxed); }
inline uint64_t timestamp() const override { return m_timestamp.load(std::memory_order_relaxed); }

9
src/workers/Workers.cpp
View file

@ -22,6 +22,7 @@
*/
#include <cmath>
#include <thread>
#include "api/Api.h"
@ -171,7 +172,13 @@ void Workers::onReady(void *arg)
handle->setWorker(new SingleWorker(handle));
}
handle->worker()->start();
const bool rc = handle->worker()->start();
if (!rc) {
uv_mutex_lock(&m_mutex);
LOG_ERR("thread %zu error: \"hash self-test failed\".", handle->worker()->id());
uv_mutex_unlock(&m_mutex);
}
}