/* 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 2018-2020 SChernykh * Copyright 2016-2020 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 "backend/common/Hashrate.h" #include "backend/common/interfaces/IBackend.h" #include "backend/common/Workers.h" #include "backend/cpu/CpuWorker.h" #include "base/io/log/Log.h" #include "base/io/log/Tags.h" #include "base/net/stratum/Pool.h" #include "base/tools/Chrono.h" #include "base/tools/Object.h" #include "core/Miner.h" #ifdef XMRIG_FEATURE_OPENCL # include "backend/opencl/OclWorker.h" #endif #ifdef XMRIG_FEATURE_CUDA # include "backend/cuda/CudaWorker.h" #endif #ifdef XMRIG_FEATURE_BENCHMARK # include "backend/common/Benchmark.h" #endif namespace xmrig { class WorkersPrivate { public: XMRIG_DISABLE_COPY_MOVE(WorkersPrivate) WorkersPrivate() = default; ~WorkersPrivate() = default; IBackend *backend = nullptr; std::shared_ptr benchmark; std::shared_ptr hashrate; }; } // namespace xmrig template xmrig::Workers::Workers() : d_ptr(new WorkersPrivate()) { } template xmrig::Workers::~Workers() { delete d_ptr; } template static void getHashrateData(xmrig::IWorker* worker, uint64_t& hashCount, uint64_t& timeStamp) { worker->getHashrateData(hashCount, timeStamp); } template<> void getHashrateData(xmrig::IWorker* worker, uint64_t& hashCount, uint64_t&) { hashCount = worker->rawHashes(); } template bool xmrig::Workers::tick(uint64_t) { if (!d_ptr->hashrate) { return true; } uint64_t ts = Chrono::steadyMSecs(); bool totalAvailable = true; uint64_t totalHashCount = 0; for (Thread *handle : m_workers) { IWorker *worker = handle->worker(); if (worker) { uint64_t hashCount; getHashrateData(worker, hashCount, ts); d_ptr->hashrate->add(handle->id() + 1, hashCount, ts); const uint64_t n = worker->rawHashes(); if (n == 0) { totalAvailable = false; } totalHashCount += n; # ifdef XMRIG_FEATURE_BENCHMARK if (d_ptr->benchmark) { d_ptr->benchmark->tick(worker); } # endif } } if (totalAvailable) { d_ptr->hashrate->add(0, totalHashCount, Chrono::steadyMSecs()); } # ifdef XMRIG_FEATURE_BENCHMARK if (d_ptr->benchmark && d_ptr->benchmark->finish(totalHashCount)) { return false; } # endif return true; } template const xmrig::Hashrate *xmrig::Workers::hashrate() const { return d_ptr->hashrate.get(); } template void xmrig::Workers::setBackend(IBackend *backend) { d_ptr->backend = backend; } template void xmrig::Workers::stop() { Nonce::stop(T::backend()); for (Thread *worker : m_workers) { delete worker; } m_workers.clear(); Nonce::touch(T::backend()); d_ptr->hashrate.reset(); } #ifdef XMRIG_FEATURE_BENCHMARK template void xmrig::Workers::start(const std::vector &data, const std::shared_ptr &benchmark) { if (!benchmark) { return start(data, true); } start(data, false); d_ptr->benchmark = benchmark; d_ptr->benchmark->start(); } #endif template xmrig::IWorker *xmrig::Workers::create(Thread *) { return nullptr; } template void xmrig::Workers::onReady(void *arg) { auto handle = static_cast* >(arg); IWorker *worker = create(handle); assert(worker != nullptr); if (!worker || !worker->selfTest()) { LOG_ERR("%s " RED("thread ") RED_BOLD("#%zu") RED(" self-test failed"), T::tag(), worker ? worker->id() : 0); handle->backend()->start(worker, false); delete worker; return; } assert(handle->backend() != nullptr); handle->setWorker(worker); handle->backend()->start(worker, true); } template void xmrig::Workers::start(const std::vector &data, bool sleep) { for (const auto &item : data) { m_workers.push_back(new Thread(d_ptr->backend, m_workers.size(), item)); } d_ptr->hashrate = std::make_shared(m_workers.size()); Nonce::touch(T::backend()); for (auto worker : m_workers) { worker->start(Workers::onReady); // This sleep is important for optimal caching! // Threads must allocate scratchpads in order so that adjacent cores will use adjacent scratchpads // Sub-optimal caching can result in up to 0.5% hashrate penalty if (sleep) { std::this_thread::sleep_for(std::chrono::milliseconds(20)); } } } namespace xmrig { template<> xmrig::IWorker *xmrig::Workers::create(Thread *handle) { switch (handle->config().intensity) { case 1: return new CpuWorker<1>(handle->id(), handle->config()); case 2: return new CpuWorker<2>(handle->id(), handle->config()); case 3: return new CpuWorker<3>(handle->id(), handle->config()); case 4: return new CpuWorker<4>(handle->id(), handle->config()); case 5: return new CpuWorker<5>(handle->id(), handle->config()); } return nullptr; } template class Workers; #ifdef XMRIG_FEATURE_OPENCL template<> xmrig::IWorker *xmrig::Workers::create(Thread *handle) { return new OclWorker(handle->id(), handle->config()); } template class Workers; #endif #ifdef XMRIG_FEATURE_CUDA template<> xmrig::IWorker *xmrig::Workers::create(Thread *handle) { return new CudaWorker(handle->id(), handle->config()); } template class Workers; #endif } // namespace xmrig