/* XMRig * Copyright 2010 Jeff Garzik * Copyright 2012-2014 pooler * Copyright 2014 Lucas Jones * Copyright 2014-2016 Wolf9466 * Copyright 2016 Jay D Dee * Copyright 2017-2018 XMR-Stak , * Copyright 2018 Lee Clagett * Copyright 2016-2018 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_test.h" #include "workers/CpuThread.h" #include "workers/MultiWorker.h" #include "workers/Workers.h" template MultiWorker::MultiWorker(Handle *handle) : Worker(handle) { } template bool MultiWorker::selfTest() { if (m_thread->fn(xmrig::VARIANT_NONE) == nullptr) { return false; } m_thread->fn(xmrig::VARIANT_NONE)(test_input, 76, m_result.result, m_ctxLegacy); 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_ctxLegacy); 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_ctxLegacy); return memcmp(m_result.result, test_output_v1_lite, 32) == 0; } # endif # ifndef XMRIG_NO_SUMO return m_thread->algorithm() == xmrig::CRYPTONIGHT_HEAVY && memcmp(m_result.result, test_output_heavy, 32) == 0; # else return false; # endif } template void MultiWorker::start() { while (Workers::sequence() > 0) { if (Workers::isPaused()) { do { std::this_thread::sleep_for(std::chrono::milliseconds(200)); } while (Workers::isPaused()); if (Workers::sequence() == 0) { break; } consumeJob(); } while (!Workers::isOutdated(m_sequence)) { if ((m_count & 0x7) == 0) { storeStats(); } m_thread->fn(m_state.job.variant())(m_state.blob, m_state.job.size(), m_hash, m_ctxLegacy); for (size_t i = 0; i < N; ++i) { if (*reinterpret_cast(m_hash + (i * 32) + 24) < m_state.job.target()) { Workers::submit(JobResult(m_state.job.poolId(), m_state.job.id(), *nonce(i), m_hash, m_state.job.diff())); } *nonce(i) += 1; } m_count += N; std::this_thread::yield(); } consumeJob(); } } template bool MultiWorker::resume(const Job &job) { if (m_state.job.poolId() == -1 && job.poolId() >= 0 && job.id() == m_pausedState.job.id()) { m_state = m_pausedState; return true; } return false; } template void MultiWorker::consumeJob() { Job job = Workers::job(); m_sequence = Workers::sequence(); if (m_state.job == job) { return; } save(job); if (resume(job)) { return; } m_state.job = job; const size_t size = m_state.job.size(); memcpy(m_state.blob, m_state.job.blob(), m_state.job.size()); if (N > 1) { for (size_t i = 1; i < N; ++i) { memcpy(m_state.blob + (i * size), m_state.blob, size); } } for (size_t i = 0; i < N; ++i) { if (m_state.job.isNicehash()) { *nonce(i) = (*nonce(i) & 0xff000000U) + (0xffffffU / m_totalWays * (m_offset + i)); } else { *nonce(i) = 0xffffffffU / m_totalWays * (m_offset + i); } } } template void MultiWorker::save(const Job &job) { if (job.poolId() == -1 && m_state.job.poolId() >= 0) { m_pausedState = m_state; } } template class MultiWorker<1>; template class MultiWorker<2>; template class MultiWorker<3>; template class MultiWorker<4>; template class MultiWorker<5>;