diff --git a/CHANGELOG.md b/CHANGELOG.md index b380d75b..feba3b05 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,6 @@ +# v4.5.0-beta +- Added NVIDIA CUDA support via external [CUDA plugun](https://github.com/xmrig/xmrig-cuda). XMRig now is unified 3 in 1 miner. + # v4.4.0-beta - [#1068](https://github.com/xmrig/xmrig/pull/1068) Added support for `self-select` stratum protocol extension. - [#1240](https://github.com/xmrig/xmrig/pull/1240) Sync with the latest RandomX code. @@ -6,7 +9,6 @@ - [#1247](https://github.com/xmrig/xmrig/pull/1247) Fixed ARM64 RandomX code alignment. - [#1248](https://github.com/xmrig/xmrig/pull/1248) Fixed RandomX code cache cleanup on iOS/Darwin. - # v4.3.1-beta - Fixed regression in v4.3.0, miner didn't create `cn` mining profile with default config example. diff --git a/CMakeLists.txt b/CMakeLists.txt index 90abfd42..849c1257 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -15,6 +15,8 @@ option(WITH_TLS "Enable OpenSSL support" ON) option(WITH_ASM "Enable ASM PoW implementations" ON) option(WITH_EMBEDDED_CONFIG "Enable internal embedded JSON config" OFF) option(WITH_OPENCL "Enable OpenCL backend" ON) +option(WITH_CUDA "Enable CUDA backend" ON) +option(WITH_NVML "Enable NVML (NVIDIA Management Library) support (only if CUDA backend enabled)" ON) option(WITH_STRICT_CACHE "Enable strict checks for OpenCL cache" ON) option(WITH_INTERLEAVE_DEBUG_LOG "Enable debug log for threads interleave" OFF) diff --git a/README.md b/README.md index e520a505..ac978393 100644 --- a/README.md +++ b/README.md @@ -9,17 +9,15 @@ [![GitHub stars](https://img.shields.io/github/stars/xmrig/xmrig.svg)](https://github.com/xmrig/xmrig/stargazers) [![GitHub forks](https://img.shields.io/github/forks/xmrig/xmrig.svg)](https://github.com/xmrig/xmrig/network) -XMRig High performance, open source, cross platform RandomX, CryptoNight and Argon2 CPU/GPU miner, with official support for Windows +XMRig High performance, open source, cross platform RandomX, CryptoNight and Argon2 CPU/GPU miner, with official support for Windows. + +## Mining backends +- **CPU** (x64/x86/ARM) +- **OpenCL** for AMD GPUs. +- **CUDA** for NVIDIA GPUs via external [CUDA plugin](https://github.com/xmrig/xmrig-cuda). -#### Table of contents -* [Download](#download) -* [Usage](#usage) -* [Build](https://github.com/xmrig/xmrig/wiki/Build) -* [Donations](#donations) -* [Contacts](#contacts) - ## Download * Binary releases: https://github.com/xmrig/xmrig/releases * Git tree: https://github.com/xmrig/xmrig.git @@ -29,6 +27,7 @@ XMRig High performance, open source, cross platform RandomX, CryptoNight and Arg The preferred way to configure the miner is the [JSON config file](src/config.json) as it is more flexible and human friendly. The command line interface does not cover all features, such as mining profiles for different algorithms. Important options can be changed during runtime without miner restart by editing the config file or executing API calls. * **[xmrig.com/wizard](https://xmrig.com/wizard)** helps you create initial configuration for the miner. +* **[workers.xmrig.info](http://workers.xmrig.info)** helps manage your miners via HTTP API. ### Command line options ``` @@ -77,13 +76,20 @@ OpenCL backend: --opencl enable OpenCL mining backend --opencl-devices=N list of OpenCL devices to use --opencl-platform=N OpenCL platform index or name - --opencl-loader=N path to OpenCL-ICD-Loader (OpenCL.dll or libOpenCL.so) + --opencl-loader=PATH path to OpenCL-ICD-Loader (OpenCL.dll or libOpenCL.so) --opencl-no-cache disable OpenCL cache --print-platforms print available OpenCL platforms and exit +CUDA backend: + --cuda enable CUDA mining backend + --cuda-loader=PATH path to CUDA plugin (xmrig-cuda.dll or libxmrig-cuda.so) + --no-nvml disable NVML (NVIDIA Management Library) support + Logging: + -S, --syslog use system log for output messages -l, --log-file=FILE log all output to a file --print-time=N print hashrate report every N seconds + --health-print-time=N print health report every N seconds --no-color disable colored output Misc: diff --git a/doc/build/CMAKE_OPTIONS.md b/doc/build/CMAKE_OPTIONS.md index 8cb66eec..fad15f50 100644 --- a/doc/build/CMAKE_OPTIONS.md +++ b/doc/build/CMAKE_OPTIONS.md @@ -21,6 +21,8 @@ This feature add external dependency to libhwloc (1.10.0+) (except MSVC builds). * **`-DWITH_TLS=OFF`** disable SSL/TLS support (secure connections to pool). This feature add external dependency to OpenSSL. * **`-DWITH_ASM=OFF`** disable assembly optimizations for modern CryptoNight algorithms. * **`-DWITH_EMBEDDED_CONFIG=ON`** Enable [embedded](https://github.com/xmrig/xmrig/issues/957) config support. +* **`-DWITH_OPENCL=OFF`** Disable OpenCL backend. +* **`-DWITH_CUDA=OFF`** Disable CUDA backend. ## Debug options diff --git a/src/App.cpp b/src/App.cpp index 7db2ace2..04b05451 100644 --- a/src/App.cpp +++ b/src/App.cpp @@ -98,29 +98,12 @@ int xmrig::App::exec() void xmrig::App::onConsoleCommand(char command) { - switch (command) { - case 'h': - case 'H': - m_controller->miner()->printHashrate(true); - break; - - case 'p': - case 'P': - m_controller->miner()->setEnabled(false); - break; - - case 'r': - case 'R': - m_controller->miner()->setEnabled(true); - break; - - case 3: + if (command == 3) { LOG_WARN("Ctrl+C received, exiting"); close(); - break; - - default: - break; + } + else { + m_controller->miner()->execCommand(command); } } diff --git a/src/Summary.cpp b/src/Summary.cpp index 2b8939a7..2055e972 100644 --- a/src/Summary.cpp +++ b/src/Summary.cpp @@ -126,9 +126,9 @@ static void print_threads(Config *config) static void print_commands(Config *) { if (Log::colors) { - Log::print(GREEN_BOLD(" * ") WHITE_BOLD("COMMANDS ") MAGENTA_BOLD("h") WHITE_BOLD("ashrate, ") - MAGENTA_BOLD("p") WHITE_BOLD("ause, ") - MAGENTA_BOLD("r") WHITE_BOLD("esume")); + Log::print(GREEN_BOLD(" * ") WHITE_BOLD("COMMANDS ") MAGENTA_BG(WHITE_BOLD_S "h") WHITE_BOLD("ashrate, ") + MAGENTA_BG(WHITE_BOLD_S "p") WHITE_BOLD("ause, ") + MAGENTA_BG(WHITE_BOLD_S "r") WHITE_BOLD("esume")); } else { Log::print(" * COMMANDS 'h' hashrate, 'p' pause, 'r' resume"); diff --git a/src/backend/backend.cmake b/src/backend/backend.cmake index 14f0ab9c..6bf6c3b2 100644 --- a/src/backend/backend.cmake +++ b/src/backend/backend.cmake @@ -1,5 +1,6 @@ include (src/backend/cpu/cpu.cmake) include (src/backend/opencl/opencl.cmake) +include (src/backend/cuda/cuda.cmake) include (src/backend/common/common.cmake) @@ -7,10 +8,12 @@ set(HEADERS_BACKEND "${HEADERS_BACKEND_COMMON}" "${HEADERS_BACKEND_CPU}" "${HEADERS_BACKEND_OPENCL}" + "${HEADERS_BACKEND_CUDA}" ) set(SOURCES_BACKEND "${SOURCES_BACKEND_COMMON}" "${SOURCES_BACKEND_CPU}" "${SOURCES_BACKEND_OPENCL}" + "${SOURCES_BACKEND_CUDA}" ) diff --git a/src/backend/common/Tags.h b/src/backend/common/Tags.h index 16022e33..9141eb72 100644 --- a/src/backend/common/Tags.h +++ b/src/backend/common/Tags.h @@ -27,10 +27,15 @@ #define XMRIG_TAGS_H +#include + + namespace xmrig { +const char *backend_tag(uint32_t backend); const char *cpu_tag(); +const char *net_tag(); #ifdef XMRIG_FEATURE_OPENCL @@ -38,6 +43,12 @@ const char *ocl_tag(); #endif +#ifdef XMRIG_FEATURE_CUDA +const char *cuda_tag(); +#endif + + + #ifdef XMRIG_ALGO_RANDOMX const char *rx_tag(); #endif diff --git a/src/backend/common/Threads.cpp b/src/backend/common/Threads.cpp index bb9e440f..f85e18f3 100644 --- a/src/backend/common/Threads.cpp +++ b/src/backend/common/Threads.cpp @@ -34,6 +34,11 @@ #endif +#ifdef XMRIG_FEATURE_CUDA +# include "backend/cuda/CudaThreads.h" +#endif + + namespace xmrig { @@ -167,4 +172,8 @@ template class Threads; template class Threads; #endif +#ifdef XMRIG_FEATURE_CUDA +template class Threads; +#endif + } // namespace xmrig diff --git a/src/backend/common/WorkerJob.h b/src/backend/common/WorkerJob.h index 6e31a701..2ea41476 100644 --- a/src/backend/common/WorkerJob.h +++ b/src/backend/common/WorkerJob.h @@ -26,7 +26,7 @@ #define XMRIG_WORKERJOB_H -#include +#include #include "base/net/stratum/Job.h" @@ -47,9 +47,9 @@ public: inline uint8_t index() const { return m_index; } - inline void add(const Job &job, uint64_t sequence, uint32_t reserveCount) + inline void add(const Job &job, uint32_t reserveCount, Nonce::Backend backend) { - m_sequence = sequence; + m_sequence = Nonce::sequence(backend); if (currentJob() == job) { return; @@ -60,7 +60,7 @@ public: return; } - save(job, reserveCount); + save(job, reserveCount, backend); } @@ -82,13 +82,15 @@ public: private: - inline void save(const Job &job, uint32_t reserveCount) + inline void save(const Job &job, uint32_t reserveCount, Nonce::Backend backend) { m_index = job.index(); const size_t size = job.size(); m_jobs[index()] = job; m_rounds[index()] = 0; + m_jobs[index()].setBackend(backend); + for (size_t i = 0; i < N; ++i) { memcpy(m_blobs[index()] + (i * size), job.blob(), size); *nonce(i) = Nonce::next(index(), *nonce(i), reserveCount, job.isNicehash()); @@ -96,7 +98,7 @@ private: } - alignas(16) uint8_t m_blobs[2][Job::kMaxBlobSize * N]; + alignas(16) uint8_t m_blobs[2][Job::kMaxBlobSize * N]{}; Job m_jobs[2]; uint32_t m_rounds[2] = { 0, 0 }; uint64_t m_sequence = 0; @@ -126,12 +128,14 @@ inline void xmrig::WorkerJob<1>::nextRound(uint32_t rounds, uint32_t roundSize) template<> -inline void xmrig::WorkerJob<1>::save(const Job &job, uint32_t reserveCount) +inline void xmrig::WorkerJob<1>::save(const Job &job, uint32_t reserveCount, Nonce::Backend backend) { m_index = job.index(); m_jobs[index()] = job; m_rounds[index()] = 0; + m_jobs[index()].setBackend(backend); + memcpy(blob(), job.blob(), job.size()); *nonce() = Nonce::next(index(), *nonce(), reserveCount, currentJob().isNicehash()); } diff --git a/src/backend/common/Workers.cpp b/src/backend/common/Workers.cpp index 9fb6859e..319f2804 100644 --- a/src/backend/common/Workers.cpp +++ b/src/backend/common/Workers.cpp @@ -37,6 +37,11 @@ #endif +#ifdef XMRIG_FEATURE_CUDA +# include "backend/cuda/CudaWorker.h" +#endif + + namespace xmrig { @@ -217,4 +222,16 @@ 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 diff --git a/src/backend/common/Workers.h b/src/backend/common/Workers.h index 2688a1e3..637a33c9 100644 --- a/src/backend/common/Workers.h +++ b/src/backend/common/Workers.h @@ -37,6 +37,11 @@ #endif +#ifdef XMRIG_FEATURE_CUDA +# include "backend/cuda/CudaLaunchData.h" +#endif + + namespace xmrig { @@ -80,6 +85,13 @@ extern template class Workers; #endif +#ifdef XMRIG_FEATURE_CUDA +template<> +IWorker *Workers::create(Thread *handle); +extern template class Workers; +#endif + + } // namespace xmrig diff --git a/src/backend/common/interfaces/IBackend.h b/src/backend/common/interfaces/IBackend.h index f9073229..c6e05bcf 100644 --- a/src/backend/common/interfaces/IBackend.h +++ b/src/backend/common/interfaces/IBackend.h @@ -53,6 +53,7 @@ public: virtual const Hashrate *hashrate() const = 0; virtual const String &profileName() const = 0; virtual const String &type() const = 0; + virtual void execCommand(char command) = 0; virtual void prepare(const Job &nextJob) = 0; virtual void printHashrate(bool details) = 0; virtual void setJob(const Job &job) = 0; diff --git a/src/backend/cpu/CpuBackend.cpp b/src/backend/cpu/CpuBackend.cpp index 78b71e25..ddee6768 100644 --- a/src/backend/cpu/CpuBackend.cpp +++ b/src/backend/cpu/CpuBackend.cpp @@ -146,10 +146,11 @@ public: inline void start() { - LOG_INFO("%s use profile " BLUE_BG(WHITE_BOLD_S " %s ") WHITE_BOLD_S " (" CYAN_BOLD("%zu") WHITE_BOLD(" threads)") " scratchpad " CYAN_BOLD("%zu KB"), + LOG_INFO("%s use profile " BLUE_BG(WHITE_BOLD_S " %s ") WHITE_BOLD_S " (" CYAN_BOLD("%zu") WHITE_BOLD(" thread%s)") " scratchpad " CYAN_BOLD("%zu KB"), tag, profileName.data(), threads.size(), + threads.size() > 1 ? "s" : "", algo.l3() / 1024 ); @@ -210,6 +211,24 @@ public: } // namespace xmrig +const char *xmrig::backend_tag(uint32_t backend) +{ +# ifdef XMRIG_FEATURE_OPENCL + if (backend == Nonce::OPENCL) { + return ocl_tag(); + } +# endif + +# ifdef XMRIG_FEATURE_CUDA + if (backend == Nonce::CUDA) { + return cuda_tag(); + } +# endif + + return tag; +} + + const char *xmrig::cpu_tag() { return tag; diff --git a/src/backend/cpu/CpuBackend.h b/src/backend/cpu/CpuBackend.h index d5d9fbf6..d0e2267a 100644 --- a/src/backend/cpu/CpuBackend.h +++ b/src/backend/cpu/CpuBackend.h @@ -50,6 +50,8 @@ public: ~CpuBackend() override; protected: + inline void execCommand(char) override {} + bool isEnabled() const override; bool isEnabled(const Algorithm &algorithm) const override; const Hashrate *hashrate() const override; diff --git a/src/backend/cpu/CpuWorker.cpp b/src/backend/cpu/CpuWorker.cpp index d6e917fb..f64882ba 100644 --- a/src/backend/cpu/CpuWorker.cpp +++ b/src/backend/cpu/CpuWorker.cpp @@ -303,7 +303,7 @@ void xmrig::CpuWorker::consumeJob() return; } - m_job.add(m_miner->job(), Nonce::sequence(Nonce::CPU), kReserveCount); + m_job.add(m_miner->job(), kReserveCount, Nonce::CPU); # ifdef XMRIG_ALGO_RANDOMX if (m_job.currentJob().algorithm().family() == Algorithm::RANDOM_X) { diff --git a/src/backend/cuda/CudaBackend.cpp b/src/backend/cuda/CudaBackend.cpp new file mode 100644 index 00000000..feb1dd93 --- /dev/null +++ b/src/backend/cuda/CudaBackend.cpp @@ -0,0 +1,519 @@ +/* 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-2019 SChernykh + * Copyright 2016-2019 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 + + +#include "backend/cuda/CudaBackend.h" +#include "backend/common/Hashrate.h" +#include "backend/common/interfaces/IWorker.h" +#include "backend/common/Tags.h" +#include "backend/common/Workers.h" +#include "backend/cuda/CudaConfig.h" +#include "backend/cuda/CudaThreads.h" +#include "backend/cuda/CudaWorker.h" +#include "backend/cuda/wrappers/CudaDevice.h" +#include "backend/cuda/wrappers/CudaLib.h" +#include "base/io/log/Log.h" +#include "base/net/stratum/Job.h" +#include "base/tools/Chrono.h" +#include "base/tools/String.h" +#include "core/config/Config.h" +#include "core/Controller.h" +#include "rapidjson/document.h" + + +#ifdef XMRIG_FEATURE_API +# include "base/api/interfaces/IApiRequest.h" +#endif + + +#ifdef XMRIG_FEATURE_NVML +#include "backend/cuda/wrappers/NvmlLib.h" + +namespace xmrig { static const char *kNvmlLabel = "NVML"; } +#endif + + +namespace xmrig { + + +extern template class Threads; + + +constexpr const size_t oneMiB = 1024u * 1024u; +static const char *kLabel = "CUDA"; +static const char *tag = GREEN_BG_BOLD(WHITE_BOLD_S " nv "); +static const String kType = "cuda"; +static std::mutex mutex; + + + +static void printDisabled(const char *label, const char *reason) +{ + Log::print(GREEN_BOLD(" * ") WHITE_BOLD("%-13s") RED_BOLD("disabled") "%s", label, reason); +} + + +struct CudaLaunchStatus +{ +public: + inline size_t threads() const { return m_threads; } + + inline bool started(bool ready) + { + ready ? m_started++ : m_errors++; + + return (m_started + m_errors) == m_threads; + } + + inline void start(size_t threads) + { + m_started = 0; + m_errors = 0; + m_threads = threads; + m_ts = Chrono::steadyMSecs(); + CudaWorker::ready = false; + } + + inline void print() const + { + if (m_started == 0) { + LOG_ERR("%s " RED_BOLD("disabled") YELLOW(" (failed to start threads)"), tag); + + return; + } + + LOG_INFO("%s" GREEN_BOLD(" READY") " threads " "%s%zu/%zu" BLACK_BOLD(" (%" PRIu64 " ms)"), + tag, + m_errors == 0 ? CYAN_BOLD_S : YELLOW_BOLD_S, + m_started, + m_threads, + Chrono::steadyMSecs() - m_ts + ); + } + +private: + size_t m_errors = 0; + size_t m_started = 0; + size_t m_threads = 0; + uint64_t m_ts = 0; +}; + + +class CudaBackendPrivate +{ +public: + inline CudaBackendPrivate(Controller *controller) : + controller(controller) + { + init(controller->config()->cuda()); + } + + + void init(const CudaConfig &cuda) + { + if (!cuda.isEnabled()) { + return printDisabled(kLabel, ""); + } + + if (!CudaLib::init(cuda.loader())) { + return printDisabled(kLabel, RED_S " (failed to load CUDA plugin)"); + } + + runtimeVersion = CudaLib::runtimeVersion(); + driverVersion = CudaLib::driverVersion(); + + if (!runtimeVersion || !driverVersion || !CudaLib::deviceCount()) { + return printDisabled(kLabel, RED_S " (no devices)"); + } + + if (!devices.empty()) { + return; + } + + Log::print(GREEN_BOLD(" * ") WHITE_BOLD("%-13s") WHITE_BOLD("%s") "/" WHITE_BOLD("%s") BLACK_BOLD("/%s"), kLabel, + CudaLib::version(runtimeVersion).c_str(), CudaLib::version(driverVersion).c_str(), CudaLib::pluginVersion()); + + devices = CudaLib::devices(cuda.bfactor(), cuda.bsleep()); + +# ifdef XMRIG_FEATURE_NVML + if (cuda.isNvmlEnabled()) { + if (NvmlLib::init(cuda.nvmlLoader())) { + NvmlLib::assign(devices); + + Log::print(GREEN_BOLD(" * ") WHITE_BOLD("%-13s") WHITE_BOLD("%s") "/" GREEN_BOLD("%s") " press " MAGENTA_BG(WHITE_BOLD_S "e") " for health report", + kNvmlLabel, + NvmlLib::version(), + NvmlLib::driverVersion() + ); + } + else { + printDisabled(kLabel, RED_S " (failed to load NVML)"); + } + } + else { + printDisabled(kNvmlLabel, ""); + } +# endif + + for (const CudaDevice &device : devices) { + Log::print(GREEN_BOLD(" * ") WHITE_BOLD("%-13s") CYAN_BOLD("#%zu") YELLOW(" %s") GREEN_BOLD(" %s ") WHITE_BOLD("%u/%u MHz") " smx:" WHITE_BOLD("%u") " arch:" WHITE_BOLD("%u%u") " mem:" CYAN("%zu/%zu") " MB", + "CUDA GPU", + device.index(), + device.topology().toString().data(), + device.name().data(), + device.clock(), + device.memoryClock(), + device.smx(), + device.computeCapability(true), + device.computeCapability(false), + device.freeMemSize() / oneMiB, + device.globalMemSize() / oneMiB); + } + } + + + inline void start(const Job &) + { + LOG_INFO("%s use profile " BLUE_BG(WHITE_BOLD_S " %s ") WHITE_BOLD_S " (" CYAN_BOLD("%zu") WHITE_BOLD(" thread%s)") " scratchpad " CYAN_BOLD("%zu KB"), + tag, + profileName.data(), + threads.size(), + threads.size() > 1 ? "s" : "", + algo.l3() / 1024 + ); + + Log::print(WHITE_BOLD("| # | GPU | BUS ID | I | T | B | BF | BS | MEM | NAME")); + + size_t i = 0; + for (const auto &data : threads) { + Log::print("|" CYAN_BOLD("%3zu") " |" CYAN_BOLD("%4u") " |" YELLOW(" %7s") " |" CYAN_BOLD("%5d") " |" CYAN_BOLD("%4d") " |" + CYAN_BOLD("%4d") " |" CYAN_BOLD("%3d") " |" CYAN_BOLD("%4d") " |" CYAN("%5zu") " | " GREEN("%s"), + i, + data.thread.index(), + data.device.topology().toString().data(), + data.thread.threads() * data.thread.blocks(), + data.thread.threads(), + data.thread.blocks(), + data.thread.bfactor(), + data.thread.bsleep(), + (data.thread.threads() * data.thread.blocks()) * algo.l3() / oneMiB, + data.device.name().data() + ); + + i++; + } + + status.start(threads.size()); + workers.start(threads); + } + + +# ifdef XMRIG_FEATURE_NVML + void printHealth() + { + for (const auto &device : devices) { + const auto health = NvmlLib::health(device.nvmlDevice()); + + std::string clocks; + if (health.clock && health.memClock) { + clocks += " " + std::to_string(health.clock) + "/" + std::to_string(health.memClock) + " MHz"; + } + + std::string fans; + if (!health.fanSpeed.empty()) { + for (uint32_t i = 0; i < health.fanSpeed.size(); ++i) { + fans += " fan" + std::to_string(i) + ":" CYAN_BOLD_S + std::to_string(health.fanSpeed[i]) + "%" CLEAR; + } + } + + LOG_INFO(CYAN_BOLD("#%u") YELLOW(" %s") MAGENTA_BOLD("%4uW") CSI "1;%um %2uC" CLEAR WHITE_BOLD("%s") "%s", + device.index(), + device.topology().toString().data(), + health.power, + health.temperature < 60 ? 32 : (health.temperature > 85 ? 31 : 33), + health.temperature, + clocks.c_str(), + fans.c_str() + ); + } + } +# endif + + + Algorithm algo; + Controller *controller; + CudaLaunchStatus status; + std::vector devices; + std::vector threads; + String profileName; + uint32_t driverVersion = 0; + uint32_t runtimeVersion = 0; + Workers workers; +}; + + +} // namespace xmrig + + +const char *xmrig::cuda_tag() +{ + return tag; +} + + +xmrig::CudaBackend::CudaBackend(Controller *controller) : + d_ptr(new CudaBackendPrivate(controller)) +{ + d_ptr->workers.setBackend(this); +} + + +xmrig::CudaBackend::~CudaBackend() +{ + delete d_ptr; + + CudaLib::close(); + +# ifdef XMRIG_FEATURE_NVML + NvmlLib::close(); +# endif +} + + +bool xmrig::CudaBackend::isEnabled() const +{ + return d_ptr->controller->config()->cuda().isEnabled() && CudaLib::isInitialized() && !d_ptr->devices.empty();; +} + + +bool xmrig::CudaBackend::isEnabled(const Algorithm &algorithm) const +{ + return !d_ptr->controller->config()->cuda().threads().get(algorithm).isEmpty(); +} + + +const xmrig::Hashrate *xmrig::CudaBackend::hashrate() const +{ + return d_ptr->workers.hashrate(); +} + + +const xmrig::String &xmrig::CudaBackend::profileName() const +{ + return d_ptr->profileName; +} + + +const xmrig::String &xmrig::CudaBackend::type() const +{ + return kType; +} + + +void xmrig::CudaBackend::execCommand(char command) +{ +# ifdef XMRIG_FEATURE_NVML + if (command == 'e' || command == 'E') { + d_ptr->printHealth(); + } +# endif +} + + +void xmrig::CudaBackend::prepare(const Job &) +{ +} + + +void xmrig::CudaBackend::printHashrate(bool details) +{ + if (!details || !hashrate()) { + return; + } + + char num[8 * 3] = { 0 }; + + Log::print(WHITE_BOLD_S "| CUDA # | AFFINITY | 10s H/s | 60s H/s | 15m H/s |"); + + size_t i = 0; + for (const auto &data : d_ptr->threads) { + Log::print("| %8zu | %8" PRId64 " | %7s | %7s | %7s |" CYAN_BOLD(" #%u") YELLOW(" %s") GREEN(" %s"), + i, + data.thread.affinity(), + Hashrate::format(hashrate()->calc(i, Hashrate::ShortInterval), num, sizeof num / 3), + Hashrate::format(hashrate()->calc(i, Hashrate::MediumInterval), num + 8, sizeof num / 3), + Hashrate::format(hashrate()->calc(i, Hashrate::LargeInterval), num + 8 * 2, sizeof num / 3), + data.device.index(), + data.device.topology().toString().data(), + data.device.name().data() + ); + + i++; + } + + Log::print(WHITE_BOLD_S "| - | - | %7s | %7s | %7s |", + Hashrate::format(hashrate()->calc(Hashrate::ShortInterval), num, sizeof num / 3), + Hashrate::format(hashrate()->calc(Hashrate::MediumInterval), num + 8, sizeof num / 3), + Hashrate::format(hashrate()->calc(Hashrate::LargeInterval), num + 8 * 2, sizeof num / 3) + ); +} + + +void xmrig::CudaBackend::setJob(const Job &job) +{ + const auto &cuda = d_ptr->controller->config()->cuda(); + if (cuda.isEnabled()) { + d_ptr->init(cuda); + } + + if (!isEnabled()) { + return stop(); + } + + auto threads = cuda.get(d_ptr->controller->miner(), job.algorithm(), d_ptr->devices); + if (!d_ptr->threads.empty() && d_ptr->threads.size() == threads.size() && std::equal(d_ptr->threads.begin(), d_ptr->threads.end(), threads.begin())) { + return; + } + + d_ptr->algo = job.algorithm(); + d_ptr->profileName = cuda.threads().profileName(job.algorithm()); + + if (d_ptr->profileName.isNull() || threads.empty()) { + LOG_WARN("%s " RED_BOLD("disabled") YELLOW(" (no suitable configuration found)"), tag); + + return stop(); + } + + stop(); + + d_ptr->threads = std::move(threads); + d_ptr->start(job); +} + + +void xmrig::CudaBackend::start(IWorker *worker, bool ready) +{ + mutex.lock(); + + if (d_ptr->status.started(ready)) { + d_ptr->status.print(); + + CudaWorker::ready = true; + } + + mutex.unlock(); + + if (ready) { + worker->start(); + } +} + + +void xmrig::CudaBackend::stop() +{ + if (d_ptr->threads.empty()) { + return; + } + + const uint64_t ts = Chrono::steadyMSecs(); + + d_ptr->workers.stop(); + d_ptr->threads.clear(); + + LOG_INFO("%s" YELLOW(" stopped") BLACK_BOLD(" (%" PRIu64 " ms)"), tag, Chrono::steadyMSecs() - ts); +} + + +void xmrig::CudaBackend::tick(uint64_t ticks) +{ + d_ptr->workers.tick(ticks); + +# ifdef XMRIG_FEATURE_NVML + auto seconds = d_ptr->controller->config()->healthPrintTime(); + if (seconds && ticks && (ticks % (seconds * 2)) == 0) { + d_ptr->printHealth(); + } +# endif +} + + +#ifdef XMRIG_FEATURE_API +rapidjson::Value xmrig::CudaBackend::toJSON(rapidjson::Document &doc) const +{ + using namespace rapidjson; + auto &allocator = doc.GetAllocator(); + + Value out(kObjectType); + out.AddMember("type", type().toJSON(), allocator); + out.AddMember("enabled", isEnabled(), allocator); + out.AddMember("algo", d_ptr->algo.toJSON(), allocator); + out.AddMember("profile", profileName().toJSON(), allocator); + + Value versions(kObjectType); + versions.AddMember("cuda-runtime", Value(CudaLib::version(d_ptr->runtimeVersion).c_str(), allocator), allocator); + versions.AddMember("cuda-driver", Value(CudaLib::version(d_ptr->driverVersion).c_str(), allocator), allocator); + versions.AddMember("plugin", String(CudaLib::pluginVersion()).toJSON(doc), allocator); + +# ifdef XMRIG_FEATURE_NVML + if (NvmlLib::isReady()) { + versions.AddMember("nvml", StringRef(NvmlLib::version()), allocator); + versions.AddMember("driver", StringRef(NvmlLib::driverVersion()), allocator); + } +# endif + + out.AddMember("versions", versions, allocator); + + if (d_ptr->threads.empty() || !hashrate()) { + return out; + } + + out.AddMember("hashrate", hashrate()->toJSON(doc), allocator); + + Value threads(kArrayType); + + size_t i = 0; + for (const auto &data : d_ptr->threads) { + Value thread = data.thread.toJSON(doc); + thread.AddMember("hashrate", hashrate()->toJSON(i, doc), allocator); + + data.device.toJSON(thread, doc); + + i++; + threads.PushBack(thread, allocator); + } + + out.AddMember("threads", threads, allocator); + + return out; +} + + +void xmrig::CudaBackend::handleRequest(IApiRequest &) +{ +} +#endif diff --git a/src/backend/cuda/CudaBackend.h b/src/backend/cuda/CudaBackend.h new file mode 100644 index 00000000..cf0bb621 --- /dev/null +++ b/src/backend/cuda/CudaBackend.h @@ -0,0 +1,80 @@ +/* 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-2019 SChernykh + * Copyright 2016-2019 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 XMRIG_CUDABACKEND_H +#define XMRIG_CUDABACKEND_H + + +#include + + +#include "backend/common/interfaces/IBackend.h" +#include "base/tools/Object.h" + + +namespace xmrig { + + +class Controller; +class CudaBackendPrivate; +class Miner; + + +class CudaBackend : public IBackend +{ +public: + XMRIG_DISABLE_COPY_MOVE_DEFAULT(CudaBackend) + + CudaBackend(Controller *controller); + + ~CudaBackend() override; + +protected: + bool isEnabled() const override; + bool isEnabled(const Algorithm &algorithm) const override; + const Hashrate *hashrate() const override; + const String &profileName() const override; + const String &type() const override; + void execCommand(char command) override; + void prepare(const Job &nextJob) override; + void printHashrate(bool details) override; + void setJob(const Job &job) override; + void start(IWorker *worker, bool ready) override; + void stop() override; + void tick(uint64_t ticks) override; + +# ifdef XMRIG_FEATURE_API + rapidjson::Value toJSON(rapidjson::Document &doc) const override; + void handleRequest(IApiRequest &request) override; +# endif + +private: + CudaBackendPrivate *d_ptr; +}; + + +} /* namespace xmrig */ + + +#endif /* XMRIG_CUDABACKEND_H */ diff --git a/src/backend/cuda/CudaConfig.cpp b/src/backend/cuda/CudaConfig.cpp new file mode 100644 index 00000000..49a28d11 --- /dev/null +++ b/src/backend/cuda/CudaConfig.cpp @@ -0,0 +1,186 @@ +/* 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-2019 SChernykh + * Copyright 2016-2019 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/cuda/CudaConfig.h" +#include "backend/common/Tags.h" +#include "backend/cuda/CudaConfig_gen.h" +#include "backend/cuda/wrappers/CudaLib.h" +#include "base/io/json/Json.h" +#include "base/io/log/Log.h" +#include "rapidjson/document.h" + + +namespace xmrig { + + +static bool generated = false; +static const char *kDevicesHint = "devices-hint"; +static const char *kEnabled = "enabled"; +static const char *kLoader = "loader"; + +#ifdef XMRIG_FEATURE_NVML +static const char *kNvml = "nvml"; +#endif + + +extern template class Threads; + + +} + + +rapidjson::Value xmrig::CudaConfig::toJSON(rapidjson::Document &doc) const +{ + using namespace rapidjson; + auto &allocator = doc.GetAllocator(); + + Value obj(kObjectType); + + obj.AddMember(StringRef(kEnabled), m_enabled, allocator); + obj.AddMember(StringRef(kLoader), m_loader.toJSON(), allocator); + +# ifdef XMRIG_FEATURE_NVML + if (m_nvmlLoader.isNull()) { + obj.AddMember(StringRef(kNvml), m_nvml, allocator); + } + else { + obj.AddMember(StringRef(kNvml), m_nvmlLoader.toJSON(), allocator); + } +# endif + + m_threads.toJSON(obj, doc); + + return obj; +} + + +std::vector xmrig::CudaConfig::get(const Miner *miner, const Algorithm &algorithm, const std::vector &devices) const +{ + std::vector out; + const auto &threads = m_threads.get(algorithm); + + if (threads.isEmpty()) { + return out; + } + + out.reserve(threads.count() * 2); + + for (const auto &thread : threads.data()) { + if (thread.index() >= devices.size()) { + LOG_INFO("%s" YELLOW(" skip non-existing device with index ") YELLOW_BOLD("%u"), cuda_tag(), thread.index()); + continue; + } + + out.emplace_back(miner, algorithm, thread, devices[thread.index()]); + } + + return out; +} + + +void xmrig::CudaConfig::read(const rapidjson::Value &value) +{ + if (value.IsObject()) { + m_enabled = Json::getBool(value, kEnabled, m_enabled); + m_loader = Json::getString(value, kLoader); + + setDevicesHint(Json::getString(value, kDevicesHint)); + +# ifdef XMRIG_FEATURE_NVML + auto &nvml = Json::getValue(value, kNvml); + if (nvml.IsString()) { + m_nvmlLoader = nvml.GetString(); + } + else if (nvml.IsBool()) { + m_nvml = nvml.GetBool(); + } +# endif + + m_threads.read(value); + + generate(); + } + else if (value.IsBool()) { + m_enabled = value.GetBool(); + + generate(); + } + else { + m_shouldSave = true; + + generate(); + } +} + + +void xmrig::CudaConfig::generate() +{ + if (generated) { + return; + } + + if (!isEnabled() || m_threads.has("*")) { + return; + } + + if (!CudaLib::init(loader())) { + return; + } + + if (!CudaLib::runtimeVersion() || !CudaLib::driverVersion() || !CudaLib::deviceCount()) { + return; + } + + const auto devices = CudaLib::devices(bfactor(), bsleep()); + if (devices.empty()) { + return; + } + + size_t count = 0; + + count += xmrig::generate(m_threads, devices); + count += xmrig::generate(m_threads, devices); + count += xmrig::generate(m_threads, devices); + count += xmrig::generate(m_threads, devices); + count += xmrig::generate(m_threads, devices); + + generated = true; + m_shouldSave = count > 0; +} + + +void xmrig::CudaConfig::setDevicesHint(const char *devicesHint) +{ + if (devicesHint == nullptr) { + return; + } + + const auto indexes = String(devicesHint).split(','); + m_devicesHint.reserve(indexes.size()); + + for (const auto &index : indexes) { + m_devicesHint.push_back(strtoul(index, nullptr, 10)); + } +} diff --git a/src/backend/cuda/CudaConfig.h b/src/backend/cuda/CudaConfig.h new file mode 100644 index 00000000..77be3dd4 --- /dev/null +++ b/src/backend/cuda/CudaConfig.h @@ -0,0 +1,86 @@ +/* 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-2019 SChernykh + * Copyright 2016-2019 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 XMRIG_CUDACONFIG_H +#define XMRIG_CUDACONFIG_H + + +#include "backend/cuda/CudaLaunchData.h" +#include "backend/common/Threads.h" +#include "backend/cuda/CudaThreads.h" + + +namespace xmrig { + + +class CudaConfig +{ +public: + CudaConfig() = default; + + rapidjson::Value toJSON(rapidjson::Document &doc) const; + std::vector get(const Miner *miner, const Algorithm &algorithm, const std::vector &devices) const; + void read(const rapidjson::Value &value); + + inline bool isEnabled() const { return m_enabled; } + inline bool isShouldSave() const { return m_shouldSave; } + inline const String &loader() const { return m_loader; } + inline const Threads &threads() const { return m_threads; } + inline int32_t bfactor() const { return m_bfactor; } + inline int32_t bsleep() const { return m_bsleep; } + +# ifdef XMRIG_FEATURE_NVML + inline bool isNvmlEnabled() const { return m_nvml; } + inline const String &nvmlLoader() const { return m_nvmlLoader; } +# endif + +private: + void generate(); + void setDevicesHint(const char *devicesHint); + + bool m_enabled = false; + bool m_shouldSave = false; + std::vector m_devicesHint; + String m_loader; + Threads m_threads; + +# ifdef _WIN32 + int32_t m_bfactor = 6; + int32_t m_bsleep = 25; +# else + int32_t m_bfactor = 0; + int32_t m_bsleep = 0; +# endif + +# ifdef XMRIG_FEATURE_NVML + bool m_nvml = true; + String m_nvmlLoader; +# endif +}; + + +} /* namespace xmrig */ + + +#endif /* XMRIG_CUDACONFIG_H */ diff --git a/src/backend/cuda/CudaConfig_gen.h b/src/backend/cuda/CudaConfig_gen.h new file mode 100644 index 00000000..87e35dc4 --- /dev/null +++ b/src/backend/cuda/CudaConfig_gen.h @@ -0,0 +1,137 @@ +/* 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-2019 SChernykh + * Copyright 2016-2019 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 XMRIG_CUDACONFIG_GEN_H +#define XMRIG_CUDACONFIG_GEN_H + + +#include "backend/common/Threads.h" +#include "backend/cuda/CudaThreads.h" +#include "backend/cuda/wrappers/CudaDevice.h" + + +#include + + +namespace xmrig { + + +static inline size_t generate(const char *key, Threads &threads, const Algorithm &algorithm, const std::vector &devices) +{ + if (threads.isExist(algorithm) || threads.has(key)) { + return 0; + } + + return threads.move(key, CudaThreads(devices, algorithm)); +} + + +template +static inline size_t generate(Threads &, const std::vector &) { return 0; } + + +template<> +size_t inline generate(Threads &threads, const std::vector &devices) +{ + size_t count = 0; + + count += generate("cn", threads, Algorithm::CN_1, devices); + count += generate("cn/2", threads, Algorithm::CN_2, devices); + + if (!threads.isExist(Algorithm::CN_0)) { + threads.disable(Algorithm::CN_0); + count++; + } + +# ifdef XMRIG_ALGO_CN_GPU + count += generate("cn/gpu", threads, Algorithm::CN_GPU, devices); +# endif + + return count; +} + + +#ifdef XMRIG_ALGO_CN_LITE +template<> +size_t inline generate(Threads &threads, const std::vector &devices) +{ + size_t count = generate("cn-lite", threads, Algorithm::CN_LITE_1, devices); + + if (!threads.isExist(Algorithm::CN_LITE_0)) { + threads.disable(Algorithm::CN_LITE_0); + ++count; + } + + return count; +} +#endif + + +#ifdef XMRIG_ALGO_CN_HEAVY +template<> +size_t inline generate(Threads &threads, const std::vector &devices) +{ + return generate("cn-heavy", threads, Algorithm::CN_HEAVY_0, devices); +} +#endif + + +#ifdef XMRIG_ALGO_CN_PICO +template<> +size_t inline generate(Threads &threads, const std::vector &devices) +{ + return generate("cn-pico", threads, Algorithm::CN_PICO_0, devices); +} +#endif + + +#ifdef XMRIG_ALGO_RANDOMX +template<> +size_t inline generate(Threads &threads, const std::vector &devices) +{ + size_t count = 0; + + auto rx = CudaThreads(devices, Algorithm::RX_0); + auto wow = CudaThreads(devices, Algorithm::RX_WOW); + auto arq = CudaThreads(devices, Algorithm::RX_ARQ); + + if (!threads.isExist(Algorithm::RX_WOW) && wow != rx) { + count += threads.move("rx/wow", std::move(wow)); + } + + if (!threads.isExist(Algorithm::RX_ARQ) && arq != rx) { + count += threads.move("rx/arq", std::move(arq)); + } + + count += threads.move("rx", std::move(rx)); + + return count; +} +#endif + + +} /* namespace xmrig */ + + +#endif /* XMRIG_CUDACONFIG_GEN_H */ diff --git a/src/backend/cuda/CudaLaunchData.cpp b/src/backend/cuda/CudaLaunchData.cpp new file mode 100644 index 00000000..11cf70c8 --- /dev/null +++ b/src/backend/cuda/CudaLaunchData.cpp @@ -0,0 +1,51 @@ +/* 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-2019 SChernykh + * Copyright 2016-2019 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/cuda/CudaLaunchData.h" +#include "backend/common/Tags.h" + + +xmrig::CudaLaunchData::CudaLaunchData(const Miner *miner, const Algorithm &algorithm, const CudaThread &thread, const CudaDevice &device) : + algorithm(algorithm), + miner(miner), + device(device), + thread(thread) +{ +} + + +bool xmrig::CudaLaunchData::isEqual(const CudaLaunchData &other) const +{ + return (other.algorithm.family() == algorithm.family() && + other.algorithm.l3() == algorithm.l3() && + other.thread == thread); +} + + +const char *xmrig::CudaLaunchData::tag() +{ + return cuda_tag(); +} diff --git a/src/backend/cuda/CudaLaunchData.h b/src/backend/cuda/CudaLaunchData.h new file mode 100644 index 00000000..33173ffb --- /dev/null +++ b/src/backend/cuda/CudaLaunchData.h @@ -0,0 +1,66 @@ +/* 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-2019 SChernykh + * Copyright 2016-2019 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 XMRIG_CUDALAUNCHDATA_H +#define XMRIG_CUDALAUNCHDATA_H + + +#include "backend/cuda/CudaThread.h" +#include "crypto/common/Algorithm.h" +#include "crypto/common/Nonce.h" + + +namespace xmrig { + + +class CudaDevice; +class Miner; + + +class CudaLaunchData +{ +public: + CudaLaunchData(const Miner *miner, const Algorithm &algorithm, const CudaThread &thread, const CudaDevice &device); + + bool isEqual(const CudaLaunchData &other) const; + + inline constexpr static Nonce::Backend backend() { return Nonce::CUDA; } + + inline bool operator!=(const CudaLaunchData &other) const { return !isEqual(other); } + inline bool operator==(const CudaLaunchData &other) const { return isEqual(other); } + + static const char *tag(); + + const Algorithm algorithm; + const Miner *miner; + const CudaDevice &device; + const CudaThread thread; +}; + + +} // namespace xmrig + + +#endif /* XMRIG_OCLLAUNCHDATA_H */ diff --git a/src/backend/cuda/CudaThread.cpp b/src/backend/cuda/CudaThread.cpp new file mode 100644 index 00000000..3100b662 --- /dev/null +++ b/src/backend/cuda/CudaThread.cpp @@ -0,0 +1,99 @@ +/* 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-2019 SChernykh + * Copyright 2016-2019 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/cuda/CudaThread.h" +#include "backend/cuda/wrappers/CudaLib.h" +#include "base/io/json/Json.h" +#include "rapidjson/document.h" + + +#include + + +namespace xmrig { + +static const char *kAffinity = "affinity"; +static const char *kBFactor = "bfactor"; +static const char *kBlocks = "blocks"; +static const char *kBSleep = "bsleep"; +static const char *kIndex = "index"; +static const char *kThreads = "threads"; + +} // namespace xmrig + + +xmrig::CudaThread::CudaThread(const rapidjson::Value &value) +{ + if (!value.IsObject()) { + return; + } + + m_index = Json::getUint(value, kIndex); + m_threads = Json::getInt(value, kThreads); + m_blocks = Json::getInt(value, kBlocks); + m_bfactor = std::min(Json::getUint(value, kBFactor, m_bfactor), 12u); + m_bsleep = Json::getUint(value, kBSleep, m_bsleep); + m_affinity = Json::getUint64(value, kAffinity, m_affinity); +} + + +xmrig::CudaThread::CudaThread(uint32_t index, nvid_ctx *ctx) : + m_blocks(CudaLib::deviceInt(ctx, CudaLib::DeviceBlocks)), + m_threads(CudaLib::deviceInt(ctx, CudaLib::DeviceThreads)), + m_index(index), + m_bfactor(CudaLib::deviceUint(ctx, CudaLib::DeviceBFactor)), + m_bsleep(CudaLib::deviceUint(ctx, CudaLib::DeviceBSleep)) +{ + +} + + +bool xmrig::CudaThread::isEqual(const CudaThread &other) const +{ + return m_blocks == other.m_blocks && + m_threads == other.m_threads && + m_affinity == other.m_affinity && + m_index == other.m_index && + m_bfactor == other.m_bfactor && + m_bsleep == other.m_bsleep; +} + + +rapidjson::Value xmrig::CudaThread::toJSON(rapidjson::Document &doc) const +{ + using namespace rapidjson; + auto &allocator = doc.GetAllocator(); + + Value out(kObjectType); + + out.AddMember(StringRef(kIndex), index(), allocator); + out.AddMember(StringRef(kThreads), threads(), allocator); + out.AddMember(StringRef(kBlocks), blocks(), allocator); + out.AddMember(StringRef(kBFactor), bfactor(), allocator); + out.AddMember(StringRef(kBSleep), bsleep(), allocator); + out.AddMember(StringRef(kAffinity), affinity(), allocator); + + return out; +} diff --git a/src/backend/cuda/CudaThread.h b/src/backend/cuda/CudaThread.h new file mode 100644 index 00000000..f6523d95 --- /dev/null +++ b/src/backend/cuda/CudaThread.h @@ -0,0 +1,79 @@ +/* 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-2019 SChernykh + * Copyright 2016-2019 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 XMRIG_CUDATHREAD_H +#define XMRIG_CUDATHREAD_H + + +using nvid_ctx = struct nvid_ctx; + + +#include "crypto/common/Algorithm.h" +#include "rapidjson/fwd.h" + + +namespace xmrig { + + +class CudaThread +{ +public: + CudaThread() = delete; + CudaThread(const rapidjson::Value &value); + CudaThread(uint32_t index, nvid_ctx *ctx); + + inline bool isValid() const { return m_blocks > 0 && m_threads > 0; } + inline int32_t bfactor() const { return static_cast(m_bfactor); } + inline int32_t blocks() const { return m_blocks; } + inline int32_t bsleep() const { return static_cast(m_bsleep); } + inline int32_t threads() const { return m_threads; } + inline int64_t affinity() const { return m_affinity; } + inline uint32_t index() const { return m_index; } + + inline bool operator!=(const CudaThread &other) const { return !isEqual(other); } + inline bool operator==(const CudaThread &other) const { return isEqual(other); } + + bool isEqual(const CudaThread &other) const; + rapidjson::Value toJSON(rapidjson::Document &doc) const; + +private: + int32_t m_blocks = 0; + int32_t m_threads = 0; + int64_t m_affinity = -1; + uint32_t m_index = 0; + +# ifdef _WIN32 + uint32_t m_bfactor = 6; + uint32_t m_bsleep = 25; +# else + uint32_t m_bfactor = 0; + uint32_t m_bsleep = 0; +# endif +}; + + +} /* namespace xmrig */ + + +#endif /* XMRIG_CUDATHREAD_H */ diff --git a/src/backend/cuda/CudaThreads.cpp b/src/backend/cuda/CudaThreads.cpp new file mode 100644 index 00000000..5ff4cb24 --- /dev/null +++ b/src/backend/cuda/CudaThreads.cpp @@ -0,0 +1,79 @@ +/* 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-2019 SChernykh + * Copyright 2016-2019 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/cuda/CudaThreads.h" +#include "base/io/json/Json.h" +#include "rapidjson/document.h" + + +#include + + +xmrig::CudaThreads::CudaThreads(const rapidjson::Value &value) +{ + if (value.IsArray()) { + for (auto &v : value.GetArray()) { + CudaThread thread(v); + if (thread.isValid()) { + add(std::move(thread)); + } + } + } +} + + +xmrig::CudaThreads::CudaThreads(const std::vector &devices, const Algorithm &algorithm) +{ + for (const auto &device : devices) { + device.generate(algorithm, *this); + } +} + + +bool xmrig::CudaThreads::isEqual(const CudaThreads &other) const +{ + if (isEmpty() && other.isEmpty()) { + return true; + } + + return count() == other.count() && std::equal(m_data.begin(), m_data.end(), other.m_data.begin()); +} + + +rapidjson::Value xmrig::CudaThreads::toJSON(rapidjson::Document &doc) const +{ + using namespace rapidjson; + auto &allocator = doc.GetAllocator(); + + Value out(kArrayType); + + out.SetArray(); + + for (const CudaThread &thread : m_data) { + out.PushBack(thread.toJSON(doc), allocator); + } + + return out; +} diff --git a/src/backend/cuda/CudaThreads.h b/src/backend/cuda/CudaThreads.h new file mode 100644 index 00000000..5f174d8e --- /dev/null +++ b/src/backend/cuda/CudaThreads.h @@ -0,0 +1,66 @@ +/* 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-2019 SChernykh + * Copyright 2016-2019 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 XMRIG_CUDATHREADS_H +#define XMRIG_CUDATHREADS_H + + +#include + + +#include "backend/cuda/CudaThread.h" +#include "backend/cuda/wrappers/CudaDevice.h" + + +namespace xmrig { + + +class CudaThreads +{ +public: + CudaThreads() = default; + CudaThreads(const rapidjson::Value &value); + CudaThreads(const std::vector &devices, const Algorithm &algorithm); + + inline bool isEmpty() const { return m_data.empty(); } + inline const std::vector &data() const { return m_data; } + inline size_t count() const { return m_data.size(); } + inline void add(CudaThread &&thread) { m_data.push_back(thread); } + inline void reserve(size_t capacity) { m_data.reserve(capacity); } + + inline bool operator!=(const CudaThreads &other) const { return !isEqual(other); } + inline bool operator==(const CudaThreads &other) const { return isEqual(other); } + + bool isEqual(const CudaThreads &other) const; + rapidjson::Value toJSON(rapidjson::Document &doc) const; + +private: + std::vector m_data; +}; + + +} /* namespace xmrig */ + + +#endif /* XMRIG_CUDATHREADS_H */ diff --git a/src/backend/cuda/CudaWorker.cpp b/src/backend/cuda/CudaWorker.cpp new file mode 100644 index 00000000..b280e294 --- /dev/null +++ b/src/backend/cuda/CudaWorker.cpp @@ -0,0 +1,171 @@ +/* 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-2019 SChernykh + * Copyright 2016-2019 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/cuda/CudaWorker.h" +#include "backend/common/Tags.h" +#include "backend/cuda/runners/CudaCnRunner.h" +#include "base/io/log/Log.h" +#include "base/tools/Chrono.h" +#include "core/Miner.h" +#include "crypto/common/Nonce.h" +#include "net/JobResults.h" + + +#ifdef XMRIG_ALGO_RANDOMX +# include "backend/cuda/runners/CudaRxRunner.h" +#endif + + +#include +#include + + +namespace xmrig { + + +static constexpr uint32_t kReserveCount = 32768; +std::atomic CudaWorker::ready; + + +static inline bool isReady() { return !Nonce::isPaused() && CudaWorker::ready; } +static inline uint32_t roundSize(uint32_t intensity) { return kReserveCount / intensity + 1; } + + +} // namespace xmrig + + + +xmrig::CudaWorker::CudaWorker(size_t id, const CudaLaunchData &data) : + Worker(id, data.thread.affinity(), -1), + m_algorithm(data.algorithm), + m_miner(data.miner) +{ + switch (m_algorithm.family()) { + case Algorithm::RANDOM_X: +# ifdef XMRIG_ALGO_RANDOMX + m_runner = new CudaRxRunner(id, data); +# endif + break; + + case Algorithm::ARGON2: + break; + + default: + m_runner = new CudaCnRunner(id, data); + break; + } + + if (!m_runner || !m_runner->init()) { + return; + } +} + + +xmrig::CudaWorker::~CudaWorker() +{ + delete m_runner; +} + + +bool xmrig::CudaWorker::selfTest() +{ + return m_runner != nullptr; +} + + +size_t xmrig::CudaWorker::intensity() const +{ + return m_runner ? m_runner->intensity() : 0; +} + + +void xmrig::CudaWorker::start() +{ + while (Nonce::sequence(Nonce::CUDA) > 0) { + if (!isReady()) { + do { + std::this_thread::sleep_for(std::chrono::milliseconds(200)); + } + while (!isReady() && Nonce::sequence(Nonce::CUDA) > 0); + + if (Nonce::sequence(Nonce::CUDA) == 0) { + break; + } + + if (!consumeJob()) { + return; + } + } + + while (!Nonce::isOutdated(Nonce::CUDA, m_job.sequence())) { + uint32_t foundNonce[10] = { 0 }; + uint32_t foundCount = 0; + + if (!m_runner->run(*m_job.nonce(), &foundCount, foundNonce)) { + return; + } + + if (foundCount) { + JobResults::submit(m_job.currentJob(), foundNonce, foundCount); + } + + const size_t batch_size = intensity(); + m_job.nextRound(roundSize(batch_size), batch_size); + + storeStats(); + std::this_thread::yield(); + } + + if (!consumeJob()) { + return; + } + } +} + + +bool xmrig::CudaWorker::consumeJob() +{ + if (Nonce::sequence(Nonce::CUDA) == 0) { + return false; + } + + const size_t batch_size = intensity(); + m_job.add(m_miner->job(), roundSize(batch_size) * batch_size, Nonce::CUDA); + + return m_runner->set(m_job.currentJob(), m_job.blob());; +} + + +void xmrig::CudaWorker::storeStats() +{ + if (!isReady()) { + return; + } + + m_count += intensity(); + + Worker::storeStats(); +} diff --git a/src/backend/cuda/CudaWorker.h b/src/backend/cuda/CudaWorker.h new file mode 100644 index 00000000..f717ca50 --- /dev/null +++ b/src/backend/cuda/CudaWorker.h @@ -0,0 +1,73 @@ +/* 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-2019 SChernykh + * Copyright 2016-2019 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 XMRIG_CUDAWORKER_H +#define XMRIG_CUDAWORKER_H + + +#include "backend/common/Worker.h" +#include "backend/common/WorkerJob.h" +#include "backend/cuda/CudaLaunchData.h" +#include "base/tools/Object.h" +#include "net/JobResult.h" + + +namespace xmrig { + + +class ICudaRunner; + + +class CudaWorker : public Worker +{ +public: + XMRIG_DISABLE_COPY_MOVE_DEFAULT(CudaWorker) + + CudaWorker(size_t id, const CudaLaunchData &data); + + ~CudaWorker() override; + + static std::atomic ready; + +protected: + bool selfTest() override; + size_t intensity() const override; + void start() override; + +private: + bool consumeJob(); + void storeStats(); + + const Algorithm m_algorithm; + const Miner *m_miner; + ICudaRunner *m_runner = nullptr; + WorkerJob<1> m_job; +}; + + +} // namespace xmrig + + +#endif /* XMRIG_CUDAWORKER_H */ diff --git a/src/backend/cuda/cuda.cmake b/src/backend/cuda/cuda.cmake new file mode 100644 index 00000000..58ba3f5a --- /dev/null +++ b/src/backend/cuda/cuda.cmake @@ -0,0 +1,53 @@ +if (WITH_CUDA) + add_definitions(/DXMRIG_FEATURE_CUDA) + + set(HEADERS_BACKEND_CUDA + src/backend/cuda/CudaBackend.h + src/backend/cuda/CudaConfig_gen.h + src/backend/cuda/CudaConfig.h + src/backend/cuda/CudaLaunchData.h + src/backend/cuda/CudaThread.h + src/backend/cuda/CudaThreads.h + src/backend/cuda/CudaWorker.h + src/backend/cuda/interfaces/ICudaRunner.h + src/backend/cuda/runners/CudaBaseRunner.h + src/backend/cuda/runners/CudaCnRunner.h + src/backend/cuda/runners/CudaRxRunner.h + src/backend/cuda/wrappers/CudaDevice.h + src/backend/cuda/wrappers/CudaLib.h + ) + + set(SOURCES_BACKEND_CUDA + src/backend/cuda/CudaBackend.cpp + src/backend/cuda/CudaConfig.cpp + src/backend/cuda/CudaLaunchData.cpp + src/backend/cuda/CudaThread.cpp + src/backend/cuda/CudaThreads.cpp + src/backend/cuda/CudaWorker.cpp + src/backend/cuda/runners/CudaBaseRunner.cpp + src/backend/cuda/runners/CudaCnRunner.cpp + src/backend/cuda/runners/CudaRxRunner.cpp + src/backend/cuda/wrappers/CudaDevice.cpp + src/backend/cuda/wrappers/CudaLib.cpp + ) + + if (WITH_NVML AND NOT APPLE) + add_definitions(/DXMRIG_FEATURE_NVML) + + list(APPEND HEADERS_BACKEND_CUDA + src/backend/cuda/wrappers/nvml_lite.h + src/backend/cuda/wrappers/NvmlHealth.h + src/backend/cuda/wrappers/NvmlLib.h + ) + + list(APPEND SOURCES_BACKEND_CUDA src/backend/cuda/wrappers/NvmlLib.cpp) + else() + remove_definitions(/DXMRIG_FEATURE_NVML) + endif() +else() + remove_definitions(/DXMRIG_FEATURE_CUDA) + remove_definitions(/DXMRIG_FEATURE_NVML) + + set(HEADERS_BACKEND_CUDA "") + set(SOURCES_BACKEND_CUDA "") +endif() diff --git a/src/backend/cuda/interfaces/ICudaRunner.h b/src/backend/cuda/interfaces/ICudaRunner.h new file mode 100644 index 00000000..b5772c89 --- /dev/null +++ b/src/backend/cuda/interfaces/ICudaRunner.h @@ -0,0 +1,71 @@ +/* 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-2019 SChernykh + * Copyright 2016-2019 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 XMRIG_ICUDARUNNER_H +#define XMRIG_ICUDARUNNER_H + + +#include "base/tools/Object.h" + + +#include + + +namespace xmrig { + + +class Job; + + +class ICudaRunner +{ +public: + XMRIG_DISABLE_COPY_MOVE(ICudaRunner) + + ICudaRunner() = default; + virtual ~ICudaRunner() = default; + +// virtual cl_context ctx() const = 0; +// virtual const Algorithm &algorithm() const = 0; +// virtual const char *buildOptions() const = 0; +// virtual const char *deviceKey() const = 0; +// virtual const char *source() const = 0; +// virtual const OclLaunchData &data() const = 0; + virtual size_t intensity() const = 0; +// virtual size_t threadId() const = 0; +// virtual uint32_t deviceIndex() const = 0; +// virtual void build() = 0; + virtual bool init() = 0; + virtual bool run(uint32_t startNonce, uint32_t *rescount, uint32_t *resnonce) = 0; + virtual bool set(const Job &job, uint8_t *blob) = 0; + +protected: +// virtual size_t bufferSize() const = 0; +}; + + +} /* namespace xmrig */ + + +#endif // XMRIG_ICUDARUNNER_H diff --git a/src/backend/cuda/runners/CudaBaseRunner.cpp b/src/backend/cuda/runners/CudaBaseRunner.cpp new file mode 100644 index 00000000..032d50c9 --- /dev/null +++ b/src/backend/cuda/runners/CudaBaseRunner.cpp @@ -0,0 +1,83 @@ +/* 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-2019 SChernykh + * Copyright 2016-2019 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/cuda/runners/CudaBaseRunner.h" +#include "backend/cuda/wrappers/CudaLib.h" +#include "backend/cuda/CudaLaunchData.h" +#include "backend/common/Tags.h" +#include "base/io/log/Log.h" +#include "base/net/stratum/Job.h" + + +xmrig::CudaBaseRunner::CudaBaseRunner(size_t id, const CudaLaunchData &data) : + m_data(data), + m_threadId(id) +{ +} + + +xmrig::CudaBaseRunner::~CudaBaseRunner() +{ + CudaLib::release(m_ctx); +} + + +bool xmrig::CudaBaseRunner::init() +{ + m_ctx = CudaLib::alloc(m_data.thread.index(), m_data.thread.bfactor(), m_data.thread.bsleep()); + if (CudaLib::deviceInfo(m_ctx, m_data.thread.blocks(), m_data.thread.threads(), m_data.algorithm) != 0) { + return false; + } + + return callWrapper(CudaLib::deviceInit(m_ctx)); +} + + +bool xmrig::CudaBaseRunner::set(const Job &job, uint8_t *blob) +{ + m_height = job.height(); + m_target = job.target(); + + return callWrapper(CudaLib::setJob(m_ctx, blob, job.size(), job.algorithm())); +} + + +size_t xmrig::CudaBaseRunner::intensity() const +{ + return m_data.thread.threads() * m_data.thread.blocks(); +} + + +bool xmrig::CudaBaseRunner::callWrapper(bool result) const +{ + if (!result) { + const char *error = CudaLib::lastError(m_ctx); + if (error) { + LOG_ERR("%s" RED_S " thread " RED_BOLD("#%zu") RED_S " failed with error " RED_BOLD("%s"), cuda_tag(), m_threadId, error); + } + } + + return result; +} diff --git a/src/backend/cuda/runners/CudaBaseRunner.h b/src/backend/cuda/runners/CudaBaseRunner.h new file mode 100644 index 00000000..c0e1aef0 --- /dev/null +++ b/src/backend/cuda/runners/CudaBaseRunner.h @@ -0,0 +1,68 @@ +/* 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-2019 SChernykh + * Copyright 2016-2019 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 XMRIG_CUDABASERUNNER_H +#define XMRIG_CUDABASERUNNER_H + + +#include "backend/cuda/interfaces/ICudaRunner.h" + + +using nvid_ctx = struct nvid_ctx; + + +namespace xmrig { + + +class CudaLaunchData; + + +class CudaBaseRunner : public ICudaRunner +{ +public: + XMRIG_DISABLE_COPY_MOVE_DEFAULT(CudaBaseRunner) + + CudaBaseRunner(size_t id, const CudaLaunchData &data); + ~CudaBaseRunner() override; + +protected: + bool init() override; + bool set(const Job &job, uint8_t *blob) override; + size_t intensity() const override; + +protected: + bool callWrapper(bool result) const; + + const CudaLaunchData &m_data; + const size_t m_threadId; + nvid_ctx *m_ctx = nullptr; + uint64_t m_height = 0; + uint64_t m_target = 0; +}; + + +} /* namespace xmrig */ + + +#endif // XMRIG_CUDABASERUNNER_H diff --git a/src/backend/cuda/runners/CudaCnRunner.cpp b/src/backend/cuda/runners/CudaCnRunner.cpp new file mode 100644 index 00000000..4d79efe3 --- /dev/null +++ b/src/backend/cuda/runners/CudaCnRunner.cpp @@ -0,0 +1,38 @@ +/* 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-2019 SChernykh + * Copyright 2016-2019 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/cuda/runners/CudaCnRunner.h" +#include "backend/cuda/wrappers/CudaLib.h" + + +xmrig::CudaCnRunner::CudaCnRunner(size_t index, const CudaLaunchData &data) : CudaBaseRunner(index, data) +{ +} + + +bool xmrig::CudaCnRunner::run(uint32_t startNonce, uint32_t *rescount, uint32_t *resnonce) +{ + return callWrapper(CudaLib::cnHash(m_ctx, startNonce, m_height, m_target, rescount, resnonce)); +} diff --git a/src/backend/cuda/runners/CudaCnRunner.h b/src/backend/cuda/runners/CudaCnRunner.h new file mode 100644 index 00000000..e563435b --- /dev/null +++ b/src/backend/cuda/runners/CudaCnRunner.h @@ -0,0 +1,48 @@ +/* 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-2019 SChernykh + * Copyright 2016-2019 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 XMRIG_CUDACNRUNNER_H +#define XMRIG_CUDACNRUNNER_H + + +#include "backend/cuda/runners/CudaBaseRunner.h" + + +namespace xmrig { + + +class CudaCnRunner : public CudaBaseRunner +{ +public: + CudaCnRunner(size_t index, const CudaLaunchData &data); + +protected: + bool run(uint32_t startNonce, uint32_t *rescount, uint32_t *resnonce) override; +}; + + +} /* namespace xmrig */ + + +#endif // XMRIG_CUDACNRUNNER_H diff --git a/src/backend/cuda/runners/CudaRxRunner.cpp b/src/backend/cuda/runners/CudaRxRunner.cpp new file mode 100644 index 00000000..83bf21ff --- /dev/null +++ b/src/backend/cuda/runners/CudaRxRunner.cpp @@ -0,0 +1,65 @@ +/* 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-2019 SChernykh + * Copyright 2016-2019 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/cuda/runners/CudaRxRunner.h" +#include "backend/cuda/CudaLaunchData.h" +#include "backend/cuda/wrappers/CudaLib.h" +#include "base/net/stratum/Job.h" +#include "crypto/rx/Rx.h" +#include "crypto/rx/RxDataset.h" + + +xmrig::CudaRxRunner::CudaRxRunner(size_t index, const CudaLaunchData &data) : CudaBaseRunner(index, data) +{ + m_intensity = m_data.thread.threads() * m_data.thread.blocks(); + const size_t scratchpads_size = m_intensity * m_data.algorithm.l3(); + const size_t num_scratchpads = scratchpads_size / m_data.algorithm.l3(); + + if (m_intensity > num_scratchpads) { + m_intensity = num_scratchpads; + } + + m_intensity -= m_intensity % 32; +} + + +bool xmrig::CudaRxRunner::run(uint32_t startNonce, uint32_t *rescount, uint32_t *resnonce) +{ + return callWrapper(CudaLib::rxHash(m_ctx, startNonce, m_target, rescount, resnonce)); +} + + +bool xmrig::CudaRxRunner::set(const Job &job, uint8_t *blob) +{ + const bool rc = CudaBaseRunner::set(job, blob); + if (!rc || m_ready) { + return rc; + } + + auto dataset = Rx::dataset(job, 0); + m_ready = callWrapper(CudaLib::rxPrepare(m_ctx, dataset->raw(), dataset->size(false), m_intensity)); + + return m_ready; +} diff --git a/src/backend/cuda/runners/CudaRxRunner.h b/src/backend/cuda/runners/CudaRxRunner.h new file mode 100644 index 00000000..06ed1b90 --- /dev/null +++ b/src/backend/cuda/runners/CudaRxRunner.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 2017-2018 XMR-Stak , + * Copyright 2018-2019 SChernykh + * Copyright 2016-2019 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 XMRIG_CUDARXRUNNER_H +#define XMRIG_CUDARXRUNNER_H + + +#include "backend/cuda/runners/CudaBaseRunner.h" + + +namespace xmrig { + + +class CudaRxRunner : public CudaBaseRunner +{ +public: + CudaRxRunner(size_t index, const CudaLaunchData &data); + +protected: + inline size_t intensity() const override { return m_intensity; } + + bool run(uint32_t startNonce, uint32_t *rescount, uint32_t *resnonce) override; + bool set(const Job &job, uint8_t *blob) override; + +private: + bool m_ready = false; + size_t m_intensity = 0; +}; + + +} /* namespace xmrig */ + + +#endif // XMRIG_CUDARXRUNNER_H diff --git a/src/backend/cuda/wrappers/CudaDevice.cpp b/src/backend/cuda/wrappers/CudaDevice.cpp new file mode 100644 index 00000000..efacc800 --- /dev/null +++ b/src/backend/cuda/wrappers/CudaDevice.cpp @@ -0,0 +1,152 @@ +/* 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-2019 SChernykh + * Copyright 2016-2019 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/cuda/wrappers/CudaDevice.h" +#include "backend/cuda/CudaThreads.h" +#include "backend/cuda/wrappers/CudaLib.h" +#include "base/io/log/Log.h" +#include "crypto/common/Algorithm.h" +#include "rapidjson/document.h" + +#ifdef XMRIG_FEATURE_NVML +# include "backend/cuda/wrappers/NvmlLib.h" +#endif + +#include + + +xmrig::CudaDevice::CudaDevice(uint32_t index, int32_t bfactor, int32_t bsleep) : + m_index(index) +{ + auto ctx = CudaLib::alloc(index, bfactor, bsleep); + if (CudaLib::deviceInfo(ctx, 0, 0, Algorithm::INVALID) != 0) { + CudaLib::release(ctx); + + return; + } + + m_ctx = ctx; + m_name = CudaLib::deviceName(ctx); + m_topology = PciTopology(CudaLib::deviceUint(ctx, CudaLib::DevicePciBusID), CudaLib::deviceUint(ctx, CudaLib::DevicePciDeviceID), 0); +} + + +xmrig::CudaDevice::CudaDevice(CudaDevice &&other) noexcept : + m_index(other.m_index), + m_ctx(other.m_ctx), + m_topology(other.m_topology), + m_name(std::move(other.m_name)) +{ + other.m_ctx = nullptr; +} + + +xmrig::CudaDevice::~CudaDevice() +{ + CudaLib::release(m_ctx); +} + + +size_t xmrig::CudaDevice::freeMemSize() const +{ + return CudaLib::deviceUlong(m_ctx, CudaLib::DeviceMemoryFree); +} + + +size_t xmrig::CudaDevice::globalMemSize() const +{ + return CudaLib::deviceUlong(m_ctx, CudaLib::DeviceMemoryTotal); +} + + +uint32_t xmrig::CudaDevice::clock() const +{ + return CudaLib::deviceUint(m_ctx, CudaLib::DeviceClockRate) / 1000; +} + + +uint32_t xmrig::CudaDevice::computeCapability(bool major) const +{ + return CudaLib::deviceUint(m_ctx, major ? CudaLib::DeviceArchMajor : CudaLib::DeviceArchMinor); +} + + +uint32_t xmrig::CudaDevice::memoryClock() const +{ + return CudaLib::deviceUint(m_ctx, CudaLib::DeviceMemoryClockRate) / 1000; +} + + +uint32_t xmrig::CudaDevice::smx() const +{ + return CudaLib::deviceUint(m_ctx, CudaLib::DeviceSmx); +} + + +void xmrig::CudaDevice::generate(const Algorithm &algorithm, CudaThreads &threads) const +{ + if (CudaLib::deviceInfo(m_ctx, -1, -1, algorithm) != 0) { + return; + } + + threads.add(CudaThread(m_index, m_ctx)); +} + + +#ifdef XMRIG_FEATURE_API +void xmrig::CudaDevice::toJSON(rapidjson::Value &out, rapidjson::Document &doc) const +{ + using namespace rapidjson; + auto &allocator = doc.GetAllocator(); + + out.AddMember("name", name().toJSON(doc), allocator); + out.AddMember("bus_id", topology().toString().toJSON(doc), allocator); + out.AddMember("smx", smx(), allocator); + out.AddMember("arch", arch(), allocator); + out.AddMember("global_mem", static_cast(globalMemSize()), allocator); + out.AddMember("clock", clock(), allocator); + out.AddMember("memory_clock", memoryClock(), allocator); + +# ifdef XMRIG_FEATURE_NVML + if (m_nvmlDevice) { + auto data = NvmlLib::health(m_nvmlDevice); + + Value health(kObjectType); + health.AddMember("temperature", data.temperature, allocator); + health.AddMember("power", data.power, allocator); + health.AddMember("clock", data.clock, allocator); + health.AddMember("mem_clock", data.memClock, allocator); + + Value fanSpeed(kArrayType); + for (auto speed : data.fanSpeed) { + fanSpeed.PushBack(speed, allocator); + } + health.AddMember("fan_speed", fanSpeed, allocator); + + out.AddMember("health", health, allocator); + } +# endif +} +#endif diff --git a/src/backend/cuda/wrappers/CudaDevice.h b/src/backend/cuda/wrappers/CudaDevice.h new file mode 100644 index 00000000..8c624c85 --- /dev/null +++ b/src/backend/cuda/wrappers/CudaDevice.h @@ -0,0 +1,94 @@ +/* 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-2019 SChernykh + * Copyright 2016-2019 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 XMRIG_CUDADEVICE_H +#define XMRIG_CUDADEVICE_H + + +#include "backend/common/misc/PciTopology.h" +#include "base/tools/String.h" + + +using nvid_ctx = struct nvid_ctx; +using nvmlDevice_t = struct nvmlDevice_st *; + + +namespace xmrig { + + +class Algorithm; +class CudaThreads; + + +class CudaDevice +{ +public: + CudaDevice() = delete; + CudaDevice(const CudaDevice &other) = delete; + CudaDevice(CudaDevice &&other) noexcept; + CudaDevice(uint32_t index, int32_t bfactor, int32_t bsleep); + ~CudaDevice(); + + size_t freeMemSize() const; + size_t globalMemSize() const; + uint32_t clock() const; + uint32_t computeCapability(bool major = true) const; + uint32_t memoryClock() const; + uint32_t smx() const; + void generate(const Algorithm &algorithm, CudaThreads &threads) const; + + inline bool isValid() const { return m_ctx != nullptr; } + inline const PciTopology &topology() const { return m_topology; } + inline const String &name() const { return m_name; } + inline uint32_t arch() const { return (computeCapability(true) * 10) + computeCapability(false); } + inline uint32_t index() const { return m_index; } + +# ifdef XMRIG_FEATURE_NVML + inline nvmlDevice_t nvmlDevice() const { return m_nvmlDevice; } + inline void setNvmlDevice(nvmlDevice_t device) { m_nvmlDevice = device; } +# endif + +# ifdef XMRIG_FEATURE_API + void toJSON(rapidjson::Value &out, rapidjson::Document &doc) const; +# endif + + CudaDevice &operator=(const CudaDevice &other) = delete; + CudaDevice &operator=(CudaDevice &&other) = delete; + +private: + const uint32_t m_index = 0; + nvid_ctx *m_ctx = nullptr; + PciTopology m_topology; + String m_name; + +# ifdef XMRIG_FEATURE_NVML + nvmlDevice_t m_nvmlDevice = nullptr; +# endif +}; + + +} // namespace xmrig + + +#endif /* XMRIG_CUDADEVICE_H */ diff --git a/src/backend/cuda/wrappers/CudaLib.cpp b/src/backend/cuda/wrappers/CudaLib.cpp new file mode 100644 index 00000000..7264d67d --- /dev/null +++ b/src/backend/cuda/wrappers/CudaLib.cpp @@ -0,0 +1,316 @@ +/* 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-2019 SChernykh + * Copyright 2016-2019 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 + + +#include "backend/cuda/wrappers/CudaLib.h" + + +namespace xmrig { + + +enum Version : uint32_t +{ + ApiVersion, + DriverVersion, + RuntimeVersion +}; + + +static uv_lib_t cudaLib; + + +static const char *kAlloc = "alloc"; +static const char *kCnHash = "cnHash"; +static const char *kDeviceCount = "deviceCount"; +static const char *kDeviceInfo = "deviceInfo"; +static const char *kDeviceInit = "deviceInit"; +static const char *kDeviceInt = "deviceInt"; +static const char *kDeviceName = "deviceName"; +static const char *kDeviceUint = "deviceUint"; +static const char *kDeviceUlong = "deviceUlong"; +static const char *kInit = "init"; +static const char *kLastError = "lastError"; +static const char *kPluginVersion = "pluginVersion"; +static const char *kRelease = "release"; +static const char *kRxHash = "rxHash"; +static const char *kRxPrepare = "rxPrepare"; +static const char *kSetJob = "setJob"; +static const char *kSymbolNotFound = "symbol not found"; +static const char *kVersion = "version"; + + +using alloc_t = nvid_ctx * (*)(uint32_t, int32_t, int32_t); +using cnHash_t = bool (*)(nvid_ctx *, uint32_t, uint64_t, uint64_t, uint32_t *, uint32_t *); +using deviceCount_t = uint32_t (*)(); +using deviceInfo_t = int32_t (*)(nvid_ctx *, int32_t, int32_t, int32_t); +using deviceInit_t = bool (*)(nvid_ctx *); +using deviceInt_t = int32_t (*)(nvid_ctx *, CudaLib::DeviceProperty); +using deviceName_t = const char * (*)(nvid_ctx *); +using deviceUint_t = uint32_t (*)(nvid_ctx *, CudaLib::DeviceProperty); +using deviceUlong_t = uint64_t (*)(nvid_ctx *, CudaLib::DeviceProperty); +using init_t = void (*)(); +using lastError_t = const char * (*)(nvid_ctx *); +using pluginVersion_t = const char * (*)(); +using release_t = void (*)(nvid_ctx *); +using rxHash_t = bool (*)(nvid_ctx *, uint32_t, uint64_t, uint32_t *, uint32_t *); +using rxPrepare_t = bool (*)(nvid_ctx *, const void *, size_t, uint32_t); +using setJob_t = bool (*)(nvid_ctx *, const void *, size_t, int32_t); +using version_t = uint32_t (*)(Version); + + +static alloc_t pAlloc = nullptr; +static cnHash_t pCnHash = nullptr; +static deviceCount_t pDeviceCount = nullptr; +static deviceInfo_t pDeviceInfo = nullptr; +static deviceInit_t pDeviceInit = nullptr; +static deviceInt_t pDeviceInt = nullptr; +static deviceName_t pDeviceName = nullptr; +static deviceUint_t pDeviceUint = nullptr; +static deviceUlong_t pDeviceUlong = nullptr; +static init_t pInit = nullptr; +static lastError_t pLastError = nullptr; +static pluginVersion_t pPluginVersion = nullptr; +static release_t pRelease = nullptr; +static rxHash_t pRxHash = nullptr; +static rxPrepare_t pRxPrepare = nullptr; +static setJob_t pSetJob = nullptr; +static version_t pVersion = nullptr; + + +#define DLSYM(x) if (uv_dlsym(&cudaLib, k##x, reinterpret_cast(&p##x)) == -1) { throw std::runtime_error(kSymbolNotFound); } + + +bool CudaLib::m_initialized = false; +bool CudaLib::m_ready = false; +String CudaLib::m_loader; + + +} // namespace xmrig + + +bool xmrig::CudaLib::init(const char *fileName) +{ + if (!m_initialized) { + m_loader = fileName == nullptr ? defaultLoader() : fileName; + m_ready = uv_dlopen(m_loader, &cudaLib) == 0 && load(); + m_initialized = true; + } + + return m_ready; +} + + +const char *xmrig::CudaLib::lastError() noexcept +{ + return uv_dlerror(&cudaLib); +} + + +void xmrig::CudaLib::close() +{ + uv_dlclose(&cudaLib); +} + + +bool xmrig::CudaLib::cnHash(nvid_ctx *ctx, uint32_t startNonce, uint64_t height, uint64_t target, uint32_t *rescount, uint32_t *resnonce) +{ + return pCnHash(ctx, startNonce, height, target, rescount, resnonce); +} + + +bool xmrig::CudaLib::deviceInit(nvid_ctx *ctx) noexcept +{ + return pDeviceInit(ctx); +} + + +bool xmrig::CudaLib::rxHash(nvid_ctx *ctx, uint32_t startNonce, uint64_t target, uint32_t *rescount, uint32_t *resnonce) noexcept +{ + return pRxHash(ctx, startNonce, target, rescount, resnonce); +} + + +bool xmrig::CudaLib::rxPrepare(nvid_ctx *ctx, const void *dataset, size_t datasetSize, uint32_t batchSize) noexcept +{ + return pRxPrepare(ctx, dataset, datasetSize, batchSize); +} + + +bool xmrig::CudaLib::setJob(nvid_ctx *ctx, const void *data, size_t size, const Algorithm &algorithm) noexcept +{ + return pSetJob(ctx, data, size, algorithm); +} + + +const char *xmrig::CudaLib::deviceName(nvid_ctx *ctx) noexcept +{ + return pDeviceName(ctx); +} + + +const char *xmrig::CudaLib::lastError(nvid_ctx *ctx) noexcept +{ + return pLastError(ctx); +} + + +const char *xmrig::CudaLib::pluginVersion() noexcept +{ + return pPluginVersion(); +} + + +int xmrig::CudaLib::deviceInfo(nvid_ctx *ctx, int32_t blocks, int32_t threads, const Algorithm &algorithm) noexcept +{ + return pDeviceInfo(ctx, blocks, threads, algorithm); +} + + +int32_t xmrig::CudaLib::deviceInt(nvid_ctx *ctx, DeviceProperty property) noexcept +{ + return pDeviceInt(ctx, property); +} + + +nvid_ctx *xmrig::CudaLib::alloc(uint32_t id, int32_t bfactor, int32_t bsleep) noexcept +{ + return pAlloc(id, bfactor, bsleep); +} + + +std::string xmrig::CudaLib::version(uint32_t version) +{ + return std::to_string(version / 1000) + "." + std::to_string((version % 1000) / 10); +} + + +std::vector xmrig::CudaLib::devices(int32_t bfactor, int32_t bsleep) noexcept +{ + const uint32_t count = deviceCount(); + if (!count) { + return {}; + } + + std::vector out; + out.reserve(count); + + for (uint32_t i = 0; i < count; ++i) { + CudaDevice device(i, bfactor, bsleep); + if (device.isValid()) { + out.emplace_back(std::move(device)); + } + } + + return out; +} + + +uint32_t xmrig::CudaLib::deviceCount() noexcept +{ + return pDeviceCount(); +} + + +uint32_t xmrig::CudaLib::deviceUint(nvid_ctx *ctx, DeviceProperty property) noexcept +{ + return pDeviceUint(ctx, property); +} + + +uint32_t xmrig::CudaLib::driverVersion() noexcept +{ + return pVersion(DriverVersion); +} + + +uint32_t xmrig::CudaLib::runtimeVersion() noexcept +{ + return pVersion(RuntimeVersion); +} + + +uint64_t xmrig::CudaLib::deviceUlong(nvid_ctx *ctx, DeviceProperty property) noexcept +{ + return pDeviceUlong(ctx, property); +} + + +void xmrig::CudaLib::release(nvid_ctx *ctx) noexcept +{ + pRelease(ctx); +} + + +bool xmrig::CudaLib::load() +{ + if (uv_dlsym(&cudaLib, kVersion, reinterpret_cast(&pVersion)) == -1) { + return false; + } + + if (pVersion(ApiVersion) != 1u) { + return false; + } + + try { + DLSYM(Alloc); + DLSYM(CnHash); + DLSYM(DeviceCount); + DLSYM(DeviceInfo); + DLSYM(DeviceInit); + DLSYM(DeviceInt); + DLSYM(DeviceName); + DLSYM(DeviceUint); + DLSYM(DeviceUlong); + DLSYM(Init); + DLSYM(LastError); + DLSYM(PluginVersion); + DLSYM(Release); + DLSYM(RxHash); + DLSYM(RxPrepare); + DLSYM(SetJob); + DLSYM(Version); + } catch (std::exception &ex) { + return false; + } + + pInit(); + + return true; +} + + +const char *xmrig::CudaLib::defaultLoader() +{ +# if defined(__APPLE__) + return "/System/Library/Frameworks/OpenCL.framework/OpenCL"; // FIXME +# elif defined(_WIN32) + return "xmrig-cuda.dll"; +# else + return "libxmrig-cuda.so"; +# endif +} diff --git a/src/backend/cuda/wrappers/CudaLib.h b/src/backend/cuda/wrappers/CudaLib.h new file mode 100644 index 00000000..7fb1c1eb --- /dev/null +++ b/src/backend/cuda/wrappers/CudaLib.h @@ -0,0 +1,107 @@ +/* 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-2019 SChernykh + * Copyright 2016-2019 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 XMRIG_CUDALIB_H +#define XMRIG_CUDALIB_H + + +using nvid_ctx = struct nvid_ctx; + + +#include "backend/cuda/wrappers/CudaDevice.h" +#include "base/tools/String.h" +#include "crypto/common/Algorithm.h" + + +#include +#include + + +namespace xmrig { + + +class CudaLib +{ +public: + enum DeviceProperty : uint32_t + { + DeviceId, + DeviceAlgorithm, + DeviceArchMajor, + DeviceArchMinor, + DeviceSmx, + DeviceBlocks, + DeviceThreads, + DeviceBFactor, + DeviceBSleep, + DeviceClockRate, + DeviceMemoryClockRate, + DeviceMemoryTotal, + DeviceMemoryFree, + DevicePciBusID, + DevicePciDeviceID, + DevicePciDomainID + }; + + static bool init(const char *fileName = nullptr); + static const char *lastError() noexcept; + static void close(); + + static inline bool isInitialized() { return m_initialized; } + static inline const String &loader() { return m_loader; } + + static bool cnHash(nvid_ctx *ctx, uint32_t startNonce, uint64_t height, uint64_t target, uint32_t *rescount, uint32_t *resnonce); + static bool deviceInit(nvid_ctx *ctx) noexcept; + static bool rxHash(nvid_ctx *ctx, uint32_t startNonce, uint64_t target, uint32_t *rescount, uint32_t *resnonce) noexcept; + static bool rxPrepare(nvid_ctx *ctx, const void *dataset, size_t datasetSize, uint32_t batchSize) noexcept; + static bool setJob(nvid_ctx *ctx, const void *data, size_t size, const Algorithm &algorithm) noexcept; + static const char *deviceName(nvid_ctx *ctx) noexcept; + static const char *lastError(nvid_ctx *ctx) noexcept; + static const char *pluginVersion() noexcept; + static int deviceInfo(nvid_ctx *ctx, int32_t blocks, int32_t threads, const Algorithm &algorithm) noexcept; + static int32_t deviceInt(nvid_ctx *ctx, DeviceProperty property) noexcept; + static nvid_ctx *alloc(uint32_t id, int32_t bfactor, int32_t bsleep) noexcept; + static std::string version(uint32_t version); + static std::vector devices(int32_t bfactor, int32_t bsleep) noexcept; + static uint32_t deviceCount() noexcept; + static uint32_t deviceUint(nvid_ctx *ctx, DeviceProperty property) noexcept; + static uint32_t driverVersion() noexcept; + static uint32_t runtimeVersion() noexcept; + static uint64_t deviceUlong(nvid_ctx *ctx, DeviceProperty property) noexcept; + static void release(nvid_ctx *ctx) noexcept; + +private: + static bool load(); + static const char *defaultLoader(); + + static bool m_initialized; + static bool m_ready; + static String m_loader; +}; + + +} // namespace xmrig + + +#endif /* XMRIG_CUDALIB_H */ diff --git a/src/backend/cuda/wrappers/NvmlHealth.h b/src/backend/cuda/wrappers/NvmlHealth.h new file mode 100644 index 00000000..58c1d3eb --- /dev/null +++ b/src/backend/cuda/wrappers/NvmlHealth.h @@ -0,0 +1,43 @@ +/* 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-2019 SChernykh + * Copyright 2016-2019 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 XMRIG_NVMLHEALTH_H +#define XMRIG_NVMLHEALTH_H + + +#include +#include + + +struct NvmlHealth +{ + std::vector fanSpeed; + uint32_t clock = 0; + uint32_t memClock = 0; + uint32_t power = 0; + uint32_t temperature = 0; +}; + + +#endif /* XMRIG_NVMLHEALTH_H */ diff --git a/src/backend/cuda/wrappers/NvmlLib.cpp b/src/backend/cuda/wrappers/NvmlLib.cpp new file mode 100644 index 00000000..cb05bdc1 --- /dev/null +++ b/src/backend/cuda/wrappers/NvmlLib.cpp @@ -0,0 +1,227 @@ +/* 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-2019 SChernykh + * Copyright 2016-2019 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 + + +#include "backend/cuda/wrappers/NvmlLib.h" +#include "backend/cuda/wrappers/nvml_lite.h" +#include "base/io/log/Log.h" + + + +namespace xmrig { + + +static uv_lib_t nvmlLib; + + +static const char *kNvmlDeviceGetClockInfo = "nvmlDeviceGetClockInfo"; +static const char *kNvmlDeviceGetCount = "nvmlDeviceGetCount_v2"; +static const char *kNvmlDeviceGetFanSpeed = "nvmlDeviceGetFanSpeed"; +static const char *kNvmlDeviceGetFanSpeed_v2 = "nvmlDeviceGetFanSpeed_v2"; +static const char *kNvmlDeviceGetHandleByIndex = "nvmlDeviceGetHandleByIndex_v2"; +static const char *kNvmlDeviceGetPciInfo = "nvmlDeviceGetPciInfo_v2"; +static const char *kNvmlDeviceGetPowerUsage = "nvmlDeviceGetPowerUsage"; +static const char *kNvmlDeviceGetTemperature = "nvmlDeviceGetTemperature"; +static const char *kNvmlInit = "nvmlInit_v2"; +static const char *kNvmlShutdown = "nvmlShutdown"; +static const char *kNvmlSystemGetDriverVersion = "nvmlSystemGetDriverVersion"; +static const char *kNvmlSystemGetNVMLVersion = "nvmlSystemGetNVMLVersion"; +static const char *kSymbolNotFound = "symbol not found"; + + +static nvmlReturn_t (*pNvmlDeviceGetClockInfo)(nvmlDevice_t device, uint32_t type, uint32_t *clock) = nullptr; +static nvmlReturn_t (*pNvmlDeviceGetCount)(uint32_t *deviceCount) = nullptr; +static nvmlReturn_t (*pNvmlDeviceGetFanSpeed_v2)(nvmlDevice_t device, uint32_t fan, uint32_t *speed) = nullptr; +static nvmlReturn_t (*pNvmlDeviceGetFanSpeed)(nvmlDevice_t device, uint32_t *speed) = nullptr; +static nvmlReturn_t (*pNvmlDeviceGetHandleByIndex)(uint32_t index, nvmlDevice_t *device) = nullptr; +static nvmlReturn_t (*pNvmlDeviceGetPciInfo)(nvmlDevice_t device, nvmlPciInfo_t *pci) = nullptr; +static nvmlReturn_t (*pNvmlDeviceGetPowerUsage)(nvmlDevice_t device, uint32_t *power) = nullptr; +static nvmlReturn_t (*pNvmlDeviceGetTemperature)(nvmlDevice_t device, uint32_t sensorType, uint32_t *temp) = nullptr; +static nvmlReturn_t (*pNvmlInit)() = nullptr; +static nvmlReturn_t (*pNvmlShutdown)() = nullptr; +static nvmlReturn_t (*pNvmlSystemGetDriverVersion)(char *version, uint32_t length) = nullptr; +static nvmlReturn_t (*pNvmlSystemGetNVMLVersion)(char *version, uint32_t length) = nullptr; + + +#define DLSYM(x) if (uv_dlsym(&nvmlLib, k##x, reinterpret_cast(&p##x)) == -1) { throw std::runtime_error(kSymbolNotFound); } + + +bool NvmlLib::m_initialized = false; +bool NvmlLib::m_ready = false; +char NvmlLib::m_driverVersion[80] = { 0 }; +char NvmlLib::m_nvmlVersion[80] = { 0 }; +String NvmlLib::m_loader; + + +} // namespace xmrig + + +bool xmrig::NvmlLib::init(const char *fileName) +{ + if (!m_initialized) { + m_loader = fileName; + m_ready = dlopen() && load(); + m_initialized = true; + } + + return m_ready; +} + + +const char *xmrig::NvmlLib::lastError() noexcept +{ + return uv_dlerror(&nvmlLib); +} + + +void xmrig::NvmlLib::close() +{ + if (m_ready) { + pNvmlShutdown(); + } + + uv_dlclose(&nvmlLib); +} + + +bool xmrig::NvmlLib::assign(std::vector &devices) +{ + uint32_t count = 0; + if (pNvmlDeviceGetCount(&count) != NVML_SUCCESS) { + return false; + } + + for (uint32_t i = 0; i < count; i++) { + nvmlDevice_t nvmlDevice; + if (pNvmlDeviceGetHandleByIndex(i, &nvmlDevice) != NVML_SUCCESS) { + continue; + } + + nvmlPciInfo_t pci; + if (pNvmlDeviceGetPciInfo(nvmlDevice, &pci) != NVML_SUCCESS) { + continue; + } + + for (auto &device : devices) { + if (device.topology().bus() == pci.bus && device.topology().device() == pci.device) { + device.setNvmlDevice(nvmlDevice); + } + } + } + + return true; +} + + +NvmlHealth xmrig::NvmlLib::health(nvmlDevice_t device) +{ + if (!device) { + return {}; + } + + NvmlHealth health; + pNvmlDeviceGetTemperature(device, NVML_TEMPERATURE_GPU, &health.temperature); + pNvmlDeviceGetPowerUsage(device, &health.power); + pNvmlDeviceGetClockInfo(device, NVML_CLOCK_SM, &health.clock); + pNvmlDeviceGetClockInfo(device, NVML_CLOCK_MEM, &health.memClock); + + if (health.power) { + health.power /= 1000; + } + + uint32_t speed = 0; + + if (pNvmlDeviceGetFanSpeed_v2) { + uint32_t i = 0; + + while (pNvmlDeviceGetFanSpeed_v2(device, i, &speed) == NVML_SUCCESS) { + health.fanSpeed.push_back(speed); + ++i; + } + + } + else { + pNvmlDeviceGetFanSpeed(device, &speed); + + health.fanSpeed.push_back(speed); + } + + return health; +} + + +bool xmrig::NvmlLib::dlopen() +{ + if (!m_loader.isNull()) { + return uv_dlopen(m_loader, &nvmlLib) == 0; + } + +# ifdef _WIN32 + if (uv_dlopen("nvml.dll", &nvmlLib) == 0) { + return true; + } + + char path[MAX_PATH] = { 0 }; + ExpandEnvironmentStringsA("%PROGRAMFILES%\\NVIDIA Corporation\\NVSMI\\nvml.dll", path, sizeof(path)); + + return uv_dlopen(path, &nvmlLib) == 0; +# else + return uv_dlopen("libnvidia-ml.so", &nvmlLib) == 0; +# endif +} + + +bool xmrig::NvmlLib::load() +{ + try { + DLSYM(NvmlDeviceGetClockInfo); + DLSYM(NvmlDeviceGetCount); + DLSYM(NvmlDeviceGetFanSpeed); + DLSYM(NvmlDeviceGetHandleByIndex); + DLSYM(NvmlDeviceGetPciInfo); + DLSYM(NvmlDeviceGetPowerUsage); + DLSYM(NvmlDeviceGetTemperature); + DLSYM(NvmlInit); + DLSYM(NvmlShutdown); + DLSYM(NvmlSystemGetDriverVersion); + DLSYM(NvmlSystemGetNVMLVersion); + } catch (std::exception &ex) { + return false; + } + + uv_dlsym(&nvmlLib, kNvmlDeviceGetFanSpeed_v2, reinterpret_cast(&pNvmlDeviceGetFanSpeed_v2)); + + if (pNvmlInit() != NVML_SUCCESS) { + return false; + } + + pNvmlSystemGetDriverVersion(m_driverVersion, sizeof(m_driverVersion)); + pNvmlSystemGetNVMLVersion(m_nvmlVersion, sizeof(m_nvmlVersion)); + + return true; +} diff --git a/src/backend/cuda/wrappers/NvmlLib.h b/src/backend/cuda/wrappers/NvmlLib.h new file mode 100644 index 00000000..85b80d0c --- /dev/null +++ b/src/backend/cuda/wrappers/NvmlLib.h @@ -0,0 +1,66 @@ +/* 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-2019 SChernykh + * Copyright 2016-2019 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 XMRIG_NVMLLIB_H +#define XMRIG_NVMLLIB_H + + +#include "backend/cuda/wrappers/CudaDevice.h" +#include "backend/cuda/wrappers/NvmlHealth.h" + + +namespace xmrig { + + +class NvmlLib +{ +public: + static bool init(const char *fileName = nullptr); + static const char *lastError() noexcept; + static void close(); + + static bool assign(std::vector &devices); + static NvmlHealth health(nvmlDevice_t device); + + static inline bool isInitialized() noexcept { return m_initialized; } + static inline bool isReady() noexcept { return m_ready; } + static inline const char *driverVersion() noexcept { return m_driverVersion; } + static inline const char *version() noexcept { return m_nvmlVersion; } + +private: + static bool dlopen(); + static bool load(); + + static bool m_initialized; + static bool m_ready; + static char m_driverVersion[80]; + static char m_nvmlVersion[80]; + static String m_loader; +}; + + +} // namespace xmrig + + +#endif /* XMRIG_NVMLLIB_H */ diff --git a/src/backend/cuda/wrappers/nvml_lite.h b/src/backend/cuda/wrappers/nvml_lite.h new file mode 100644 index 00000000..4472847c --- /dev/null +++ b/src/backend/cuda/wrappers/nvml_lite.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 2017-2018 XMR-Stak , + * Copyright 2018-2019 SChernykh + * Copyright 2016-2019 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 XMRIG_NVML_LITE_H +#define XMRIG_NVML_LITE_H + + +#include + + +#define NVML_SUCCESS 0 +#define NVML_TEMPERATURE_GPU 0 +#define NVML_CLOCK_SM 1 +#define NVML_CLOCK_MEM 2 + + +using nvmlReturn_t = uint32_t; +using nvmlDevice_t = struct nvmlDevice_st *; + + +struct nvmlPciInfo_t +{ + char busIdLegacy[16]{}; + unsigned int domain = 0; + unsigned int bus = 0; + unsigned int device = 0; + unsigned int pciDeviceId = 0; + unsigned int pciSubSystemId = 0; + + char busId[32]{}; +}; + + +#endif /* XMRIG_NVML_LITE_H */ diff --git a/src/backend/opencl/OclBackend.cpp b/src/backend/opencl/OclBackend.cpp index 5b078006..bbf60443 100644 --- a/src/backend/opencl/OclBackend.cpp +++ b/src/backend/opencl/OclBackend.cpp @@ -153,7 +153,8 @@ public: Log::print(GREEN_BOLD(" * ") WHITE_BOLD("%-13s") CYAN_BOLD("#%zu ") WHITE_BOLD("%s") "/" WHITE_BOLD("%s"), "OPENCL", platform.index(), platform.name().data(), platform.version().data()); for (const OclDevice &device : devices) { - Log::print(GREEN_BOLD(" * ") WHITE_BOLD("%-13s") CYAN_BOLD("#%zu") YELLOW(" %s") " %s " WHITE_BOLD("%uMHz") " cu:" WHITE_BOLD("%u") " mem:" CYAN("%zu/%zu") " MB", "OPENCL GPU", + Log::print(GREEN_BOLD(" * ") WHITE_BOLD("%-13s") CYAN_BOLD("#%zu") YELLOW(" %s") " %s " WHITE_BOLD("%u MHz") " cu:" WHITE_BOLD("%u") " mem:" CYAN("%zu/%zu") " MB", + "OPENCL GPU", device.index(), device.topology().toString().data(), device.printableName().data(), @@ -167,10 +168,11 @@ public: inline void start(const Job &job) { - LOG_INFO("%s use profile " BLUE_BG(WHITE_BOLD_S " %s ") WHITE_BOLD_S " (" CYAN_BOLD("%zu") WHITE_BOLD(" threads)") " scratchpad " CYAN_BOLD("%zu KB"), + LOG_INFO("%s use profile " BLUE_BG(WHITE_BOLD_S " %s ") WHITE_BOLD_S " (" CYAN_BOLD("%zu") WHITE_BOLD(" thread%s)") " scratchpad " CYAN_BOLD("%zu KB"), tag, profileName.data(), threads.size(), + threads.size() > 1 ? "s" : "", algo.l3() / 1024 ); @@ -284,7 +286,7 @@ void xmrig::OclBackend::printHashrate(bool details) Log::print(WHITE_BOLD_S "| OPENCL # | AFFINITY | 10s H/s | 60s H/s | 15m H/s |"); size_t i = 0; - for (const OclLaunchData &data : d_ptr->threads) { + for (const auto &data : d_ptr->threads) { Log::print("| %8zu | %8" PRId64 " | %7s | %7s | %7s |" CYAN_BOLD(" #%u") YELLOW(" %s") " %s", i, data.affinity, @@ -309,7 +311,7 @@ void xmrig::OclBackend::printHashrate(bool details) void xmrig::OclBackend::setJob(const Job &job) { - const OclConfig &cl = d_ptr->controller->config()->cl(); + const auto &cl = d_ptr->controller->config()->cl(); if (cl.isEnabled()) { d_ptr->init(cl); } @@ -318,7 +320,7 @@ void xmrig::OclBackend::setJob(const Job &job) return stop(); } - std::vector threads = cl.get(d_ptr->controller->miner(), job.algorithm(), d_ptr->platform, d_ptr->devices, tag); + auto threads = cl.get(d_ptr->controller->miner(), job.algorithm(), d_ptr->platform, d_ptr->devices); if (!d_ptr->threads.empty() && d_ptr->threads.size() == threads.size() && std::equal(d_ptr->threads.begin(), d_ptr->threads.end(), threads.begin())) { return; } @@ -408,7 +410,7 @@ rapidjson::Value xmrig::OclBackend::toJSON(rapidjson::Document &doc) const Value threads(kArrayType); size_t i = 0; - for (const OclLaunchData &data : d_ptr->threads) { + for (const auto &data : d_ptr->threads) { Value thread = data.thread.toJSON(doc); thread.AddMember("affinity", data.affinity, allocator); thread.AddMember("hashrate", hashrate()->toJSON(i, doc), allocator); diff --git a/src/backend/opencl/OclBackend.h b/src/backend/opencl/OclBackend.h index ade560ba..59bea0aa 100644 --- a/src/backend/opencl/OclBackend.h +++ b/src/backend/opencl/OclBackend.h @@ -30,6 +30,7 @@ #include "backend/common/interfaces/IBackend.h" +#include "base/tools/Object.h" namespace xmrig { @@ -43,17 +44,15 @@ class Miner; class OclBackend : public IBackend { public: - OclBackend() = delete; - OclBackend(const OclBackend &other) = delete; + XMRIG_DISABLE_COPY_MOVE_DEFAULT(OclBackend) + OclBackend(Controller *controller); - OclBackend(OclBackend &&other) = delete; ~OclBackend() override; - OclBackend &operator=(const OclBackend &other) = delete; - OclBackend &operator=(OclBackend &&other) = delete; - protected: + inline void execCommand(char) override {} + bool isEnabled() const override; bool isEnabled(const Algorithm &algorithm) const override; const Hashrate *hashrate() const override; diff --git a/src/backend/opencl/OclConfig.cpp b/src/backend/opencl/OclConfig.cpp index 71a669d6..ec01adaf 100644 --- a/src/backend/opencl/OclConfig.cpp +++ b/src/backend/opencl/OclConfig.cpp @@ -24,6 +24,7 @@ #include "backend/opencl/OclConfig.h" +#include "backend/common/Tags.h" #include "backend/opencl/OclConfig_gen.h" #include "backend/opencl/wrappers/OclLib.h" #include "base/io/json/Json.h" @@ -113,10 +114,10 @@ rapidjson::Value xmrig::OclConfig::toJSON(rapidjson::Document &doc) const } -std::vector xmrig::OclConfig::get(const Miner *miner, const Algorithm &algorithm, const OclPlatform &platform, const std::vector &devices, const char *tag) const +std::vector xmrig::OclConfig::get(const Miner *miner, const Algorithm &algorithm, const OclPlatform &platform, const std::vector &devices) const { std::vector out; - const OclThreads &threads = m_threads.get(algorithm); + const auto &threads = m_threads.get(algorithm); if (threads.isEmpty()) { return out; @@ -124,9 +125,9 @@ std::vector xmrig::OclConfig::get(const Miner *miner, cons out.reserve(threads.count() * 2); - for (const OclThread &thread : threads.data()) { + for (const auto &thread : threads.data()) { if (thread.index() >= devices.size()) { - LOG_INFO("%s" YELLOW(" skip non-existing device with index ") YELLOW_BOLD("%u"), tag, thread.index()); + LOG_INFO("%s" YELLOW(" skip non-existing device with index ") YELLOW_BOLD("%u"), ocl_tag(), thread.index()); continue; } diff --git a/src/backend/opencl/OclConfig.h b/src/backend/opencl/OclConfig.h index 9dd5ad1d..8e2db042 100644 --- a/src/backend/opencl/OclConfig.h +++ b/src/backend/opencl/OclConfig.h @@ -42,7 +42,7 @@ public: OclPlatform platform() const; rapidjson::Value toJSON(rapidjson::Document &doc) const; - std::vector get(const Miner *miner, const Algorithm &algorithm, const OclPlatform &platform, const std::vector &devices, const char *tag) const; + std::vector get(const Miner *miner, const Algorithm &algorithm, const OclPlatform &platform, const std::vector &devices) const; void read(const rapidjson::Value &value); inline bool isCacheEnabled() const { return m_cache; } diff --git a/src/backend/opencl/OclThreads.cpp b/src/backend/opencl/OclThreads.cpp index 167ccfc0..3e53a5f5 100644 --- a/src/backend/opencl/OclThreads.cpp +++ b/src/backend/opencl/OclThreads.cpp @@ -46,7 +46,7 @@ xmrig::OclThreads::OclThreads(const rapidjson::Value &value) xmrig::OclThreads::OclThreads(const std::vector &devices, const Algorithm &algorithm) { - for (const OclDevice &device : devices) { + for (const auto &device : devices) { device.generate(algorithm, *this); } } diff --git a/src/backend/opencl/OclWorker.cpp b/src/backend/opencl/OclWorker.cpp index f79bc59b..83b83dae 100644 --- a/src/backend/opencl/OclWorker.cpp +++ b/src/backend/opencl/OclWorker.cpp @@ -206,7 +206,7 @@ bool xmrig::OclWorker::consumeJob() return false; } - m_job.add(m_miner->job(), Nonce::sequence(Nonce::OPENCL), roundSize(m_intensity) * m_intensity); + m_job.add(m_miner->job(), roundSize(m_intensity) * m_intensity, Nonce::OPENCL); try { m_runner->set(m_job.currentJob(), m_job.blob()); diff --git a/src/backend/opencl/OclWorker.h b/src/backend/opencl/OclWorker.h index 76cb63db..01803f70 100644 --- a/src/backend/opencl/OclWorker.h +++ b/src/backend/opencl/OclWorker.h @@ -30,6 +30,7 @@ #include "backend/common/Worker.h" #include "backend/common/WorkerJob.h" #include "backend/opencl/OclLaunchData.h" +#include "base/tools/Object.h" #include "net/JobResult.h" @@ -42,16 +43,12 @@ class IOclRunner; class OclWorker : public Worker { public: - OclWorker() = delete; - OclWorker(const OclWorker &other) = delete; - OclWorker(OclWorker &&other) = delete; + XMRIG_DISABLE_COPY_MOVE_DEFAULT(OclWorker) + OclWorker(size_t id, const OclLaunchData &data); ~OclWorker() override; - OclWorker &operator=(const OclWorker &other) = delete; - OclWorker &operator=(OclWorker &&other) = delete; - static std::atomic ready; protected: diff --git a/src/backend/opencl/runners/OclBaseRunner.cpp b/src/backend/opencl/runners/OclBaseRunner.cpp index d8497e94..2e75d9b6 100644 --- a/src/backend/opencl/runners/OclBaseRunner.cpp +++ b/src/backend/opencl/runners/OclBaseRunner.cpp @@ -39,8 +39,8 @@ constexpr size_t oneGiB = 1024 * 1024 * 1024; xmrig::OclBaseRunner::OclBaseRunner(size_t id, const OclLaunchData &data) : - m_algorithm(data.algorithm), m_ctx(data.ctx), + m_algorithm(data.algorithm), m_source(OclSource::get(data.algorithm)), m_data(data), m_align(OclLib::getUint(data.device.id(), CL_DEVICE_MEM_BASE_ADDR_ALIGN)), diff --git a/src/backend/opencl/runners/OclBaseRunner.h b/src/backend/opencl/runners/OclBaseRunner.h index 558d6807..6abbb2b7 100644 --- a/src/backend/opencl/runners/OclBaseRunner.h +++ b/src/backend/opencl/runners/OclBaseRunner.h @@ -70,21 +70,21 @@ protected: void enqueueWriteBuffer(cl_mem buffer, cl_bool blocking_write, size_t offset, size_t size, const void *ptr); void finalize(uint32_t *hashOutput); - Algorithm m_algorithm; cl_command_queue m_queue = nullptr; cl_context m_ctx; cl_mem m_buffer = nullptr; cl_mem m_input = nullptr; cl_mem m_output = nullptr; cl_program m_program = nullptr; + const Algorithm m_algorithm; const char *m_source; const OclLaunchData &m_data; const size_t m_align; const size_t m_threadId; + const uint32_t m_intensity; size_t m_offset = 0; std::string m_deviceKey; std::string m_options; - uint32_t m_intensity; }; diff --git a/src/backend/opencl/wrappers/OclDevice.h b/src/backend/opencl/wrappers/OclDevice.h index 04577d90..7d081618 100644 --- a/src/backend/opencl/wrappers/OclDevice.h +++ b/src/backend/opencl/wrappers/OclDevice.h @@ -26,14 +26,13 @@ #define XMRIG_OCLDEVICE_H -#include - - #include "backend/common/misc/PciTopology.h" #include "backend/opencl/wrappers/OclVendor.h" #include "base/tools/String.h" #include +#include + using cl_device_id = struct _cl_device_id *; using cl_platform_id = struct _cl_platform_id *; diff --git a/src/backend/opencl/wrappers/OclLib.cpp b/src/backend/opencl/wrappers/OclLib.cpp index 1b530bae..f156ed3d 100644 --- a/src/backend/opencl/wrappers/OclLib.cpp +++ b/src/backend/opencl/wrappers/OclLib.cpp @@ -77,6 +77,7 @@ static const char *kRetainMemObject = "clRetainMemObject"; static const char *kRetainProgram = "clRetainProgram"; static const char *kSetKernelArg = "clSetKernelArg"; static const char *kSetMemObjectDestructorCallback = "clSetMemObjectDestructorCallback"; +static const char *kSymbolNotFound = "symbol not found"; static const char *kUnloadPlatformCompiler = "clUnloadPlatformCompiler"; @@ -156,7 +157,7 @@ static setKernelArg_t pSetKernelArg = nu static setMemObjectDestructorCallback_t pSetMemObjectDestructorCallback = nullptr; static unloadPlatformCompiler_t pUnloadPlatformCompiler = nullptr; -#define DLSYM(x) if (uv_dlsym(&oclLib, k##x, reinterpret_cast(&p##x)) == -1) { return false; } +#define DLSYM(x) if (uv_dlsym(&oclLib, k##x, reinterpret_cast(&p##x)) == -1) { throw std::runtime_error(kSymbolNotFound); } namespace xmrig { @@ -210,39 +211,43 @@ void xmrig::OclLib::close() bool xmrig::OclLib::load() { - DLSYM(CreateCommandQueue); - DLSYM(CreateContext); - DLSYM(BuildProgram); - DLSYM(EnqueueNDRangeKernel); - DLSYM(EnqueueReadBuffer); - DLSYM(EnqueueWriteBuffer); - DLSYM(Finish); - DLSYM(GetDeviceIDs); - DLSYM(GetDeviceInfo); - DLSYM(GetPlatformInfo); - DLSYM(GetPlatformIDs); - DLSYM(GetProgramBuildInfo); - DLSYM(GetProgramInfo); - DLSYM(SetKernelArg); - DLSYM(CreateKernel); - DLSYM(CreateBuffer); - DLSYM(CreateProgramWithBinary); - DLSYM(CreateProgramWithSource); - DLSYM(ReleaseMemObject); - DLSYM(ReleaseProgram); - DLSYM(ReleaseKernel); - DLSYM(ReleaseCommandQueue); - DLSYM(ReleaseContext); - DLSYM(GetKernelInfo); - DLSYM(GetCommandQueueInfo); - DLSYM(GetMemObjectInfo); - DLSYM(GetContextInfo); - DLSYM(ReleaseDevice); - DLSYM(UnloadPlatformCompiler); - DLSYM(SetMemObjectDestructorCallback); - DLSYM(CreateSubBuffer); - DLSYM(RetainProgram); - DLSYM(RetainMemObject); + try { + DLSYM(CreateCommandQueue); + DLSYM(CreateContext); + DLSYM(BuildProgram); + DLSYM(EnqueueNDRangeKernel); + DLSYM(EnqueueReadBuffer); + DLSYM(EnqueueWriteBuffer); + DLSYM(Finish); + DLSYM(GetDeviceIDs); + DLSYM(GetDeviceInfo); + DLSYM(GetPlatformInfo); + DLSYM(GetPlatformIDs); + DLSYM(GetProgramBuildInfo); + DLSYM(GetProgramInfo); + DLSYM(SetKernelArg); + DLSYM(CreateKernel); + DLSYM(CreateBuffer); + DLSYM(CreateProgramWithBinary); + DLSYM(CreateProgramWithSource); + DLSYM(ReleaseMemObject); + DLSYM(ReleaseProgram); + DLSYM(ReleaseKernel); + DLSYM(ReleaseCommandQueue); + DLSYM(ReleaseContext); + DLSYM(GetKernelInfo); + DLSYM(GetCommandQueueInfo); + DLSYM(GetMemObjectInfo); + DLSYM(GetContextInfo); + DLSYM(ReleaseDevice); + DLSYM(UnloadPlatformCompiler); + DLSYM(SetMemObjectDestructorCallback); + DLSYM(CreateSubBuffer); + DLSYM(RetainProgram); + DLSYM(RetainMemObject); + } catch (std::exception &ex) { + return false; + } # if defined(CL_VERSION_2_0) uv_dlsym(&oclLib, kCreateCommandQueueWithProperties, reinterpret_cast(&pCreateCommandQueueWithProperties)); diff --git a/src/base/io/log/Log.h b/src/base/io/log/Log.h index 3517b61d..cfd3c3a3 100644 --- a/src/base/io/log/Log.h +++ b/src/base/io/log/Log.h @@ -82,6 +82,7 @@ private: #define WHITE_S CSI "0;37m" // another name for LT.GRAY #define WHITE_BOLD_S CSI "1;37m" // actually white +#define GREEN_BG_BOLD_S CSI "42;1m" #define BLUE_BG_S CSI "44m" #define BLUE_BG_BOLD_S CSI "44;1m" #define MAGENTA_BG_S CSI "45m" @@ -107,6 +108,7 @@ private: #define WHITE(x) WHITE_S x CLEAR #define WHITE_BOLD(x) WHITE_BOLD_S x CLEAR +#define GREEN_BG_BOLD(x) GREEN_BG_BOLD_S x CLEAR #define BLUE_BG(x) BLUE_BG_S x CLEAR #define BLUE_BG_BOLD(x) BLUE_BG_BOLD_S x CLEAR #define MAGENTA_BG(x) MAGENTA_BG_S x CLEAR diff --git a/src/base/kernel/interfaces/IConfig.h b/src/base/kernel/interfaces/IConfig.h index 9f8d9618..7167e0bb 100644 --- a/src/base/kernel/interfaces/IConfig.h +++ b/src/base/kernel/interfaces/IConfig.h @@ -134,6 +134,10 @@ public: CudaLaunchKey = 1204, CudaAffinityKey = 1205, CudaMaxUsageKey = 1206, + CudaKey = 1207, + CudaLoaderKey = 1208, + NvmlKey = 1209, + HealthPrintTimeKey = 1210, }; virtual ~IConfig() = default; diff --git a/src/base/net/stratum/Client.cpp b/src/base/net/stratum/Client.cpp index 3619e4e9..9729f3fb 100644 --- a/src/base/net/stratum/Client.cpp +++ b/src/base/net/stratum/Client.cpp @@ -212,9 +212,9 @@ int64_t xmrig::Client::submit(const JobResult &result) JsonRequest::create(doc, m_sequence, "submit", params); # ifdef XMRIG_PROXY_PROJECT - m_results[m_sequence] = SubmitResult(m_sequence, result.diff, result.actualDiff(), result.id); + m_results[m_sequence] = SubmitResult(m_sequence, result.diff, result.actualDiff(), result.id, 0); # else - m_results[m_sequence] = SubmitResult(m_sequence, result.diff, result.actualDiff()); + m_results[m_sequence] = SubmitResult(m_sequence, result.diff, result.actualDiff(), 0, result.backend); # endif return send(doc); diff --git a/src/base/net/stratum/DaemonClient.cpp b/src/base/net/stratum/DaemonClient.cpp index 0870dc1d..09f2a7f9 100644 --- a/src/base/net/stratum/DaemonClient.cpp +++ b/src/base/net/stratum/DaemonClient.cpp @@ -117,9 +117,9 @@ int64_t xmrig::DaemonClient::submit(const JobResult &result) JsonRequest::create(doc, m_sequence, "submitblock", params); # ifdef XMRIG_PROXY_PROJECT - m_results[m_sequence] = SubmitResult(m_sequence, result.diff, result.actualDiff(), result.id); + m_results[m_sequence] = SubmitResult(m_sequence, result.diff, result.actualDiff(), result.id, 0); # else - m_results[m_sequence] = SubmitResult(m_sequence, result.diff, result.actualDiff()); + m_results[m_sequence] = SubmitResult(m_sequence, result.diff, result.actualDiff(), 0, result.backend); # endif send(HTTP_POST, kJsonRPC, doc); diff --git a/src/base/net/stratum/Job.cpp b/src/base/net/stratum/Job.cpp index ef1b03b5..1de1c19b 100644 --- a/src/base/net/stratum/Job.cpp +++ b/src/base/net/stratum/Job.cpp @@ -157,6 +157,7 @@ void xmrig::Job::copy(const Job &other) m_size = other.m_size; m_clientId = other.m_clientId; m_id = other.m_id; + m_backend = other.m_backend; m_diff = other.m_diff; m_height = other.m_height; m_target = other.m_target; @@ -174,3 +175,34 @@ void xmrig::Job::copy(const Job &other) memcpy(m_rawTarget, other.m_rawTarget, sizeof(m_rawTarget)); # endif } + + +void xmrig::Job::move(Job &&other) +{ + m_algorithm = other.m_algorithm; + m_nicehash = other.m_nicehash; + m_size = other.m_size; + m_clientId = std::move(other.m_clientId); + m_id = std::move(other.m_id); + m_backend = other.m_backend; + m_diff = other.m_diff; + m_height = other.m_height; + m_target = other.m_target; + m_index = other.m_index; + m_seed = std::move(other.m_seed); + m_extraNonce = std::move(other.m_extraNonce); + m_poolWallet = std::move(other.m_poolWallet); + + memcpy(m_blob, other.m_blob, sizeof(m_blob)); + + other.m_size = 0; + other.m_diff = 0; + other.m_algorithm = Algorithm::INVALID; + +# ifdef XMRIG_PROXY_PROJECT + m_rawSeedHash = std::move(other.m_rawSeedHash); + + memcpy(m_rawBlob, other.m_rawBlob, sizeof(m_rawBlob)); + memcpy(m_rawTarget, other.m_rawTarget, sizeof(m_rawTarget)); +# endif +} diff --git a/src/base/net/stratum/Job.h b/src/base/net/stratum/Job.h index 3c4c4724..9e1f3bc9 100644 --- a/src/base/net/stratum/Job.h +++ b/src/base/net/stratum/Job.h @@ -50,6 +50,10 @@ public: Job() = default; Job(bool nicehash, const Algorithm &algorithm, const String &clientId); + + inline Job(const Job &other) { copy(other); } + inline Job(Job &&other) noexcept { move(std::move(other)); } + ~Job() = default; bool isEqual(const Job &other) const; @@ -71,6 +75,7 @@ public: inline const uint8_t *blob() const { return m_blob; } inline size_t size() const { return m_size; } inline uint32_t *nonce() { return reinterpret_cast(m_blob + 39); } + inline uint32_t backend() const { return m_backend; } inline uint64_t diff() const { return m_diff; } inline uint64_t height() const { return m_height; } inline uint64_t target() const { return m_target; } @@ -79,6 +84,7 @@ public: inline void reset() { m_size = 0; m_diff = 0; } inline void setAlgorithm(const Algorithm::Id id) { m_algorithm = id; } inline void setAlgorithm(const char *algo) { m_algorithm = algo; } + inline void setBackend(uint32_t backend) { m_backend = backend; } inline void setClientId(const String &id) { m_clientId = id; } inline void setExtraNonce(const String &extraNonce) { m_extraNonce = extraNonce; } inline void setHeight(uint64_t height) { m_height = height; } @@ -95,12 +101,14 @@ public: static inline uint32_t *nonce(uint8_t *blob) { return reinterpret_cast(blob + 39); } static inline uint64_t toDiff(uint64_t target) { return 0xFFFFFFFFFFFFFFFFULL / target; } - inline bool operator==(const Job &other) const { return isEqual(other); } inline bool operator!=(const Job &other) const { return !isEqual(other); } + inline bool operator==(const Job &other) const { return isEqual(other); } inline Job &operator=(const Job &other) { copy(other); return *this; } + inline Job &operator=(Job &&other) noexcept { move(std::move(other)); return *this; } private: void copy(const Job &other); + void move(Job &&other); Algorithm m_algorithm; bool m_nicehash = false; @@ -110,6 +118,7 @@ private: String m_extraNonce; String m_id; String m_poolWallet; + uint32_t m_backend = 0; uint64_t m_diff = 0; uint64_t m_height = 0; uint64_t m_target = 0; @@ -117,8 +126,8 @@ private: uint8_t m_index = 0; # ifdef XMRIG_PROXY_PROJECT - char m_rawBlob[kMaxBlobSize * 2 + 8]; - char m_rawTarget[24]; + char m_rawBlob[kMaxBlobSize * 2 + 8]{}; + char m_rawTarget[24]{}; String m_rawSeedHash; # endif }; diff --git a/src/base/net/stratum/Pool.cpp b/src/base/net/stratum/Pool.cpp index eb2fe506..59b70b11 100644 --- a/src/base/net/stratum/Pool.cpp +++ b/src/base/net/stratum/Pool.cpp @@ -28,6 +28,7 @@ #include #include #include +#include #include "base/net/stratum/Pool.h" diff --git a/src/base/net/stratum/SubmitResult.h b/src/base/net/stratum/SubmitResult.h index 1b49acb4..a180f6fa 100644 --- a/src/base/net/stratum/SubmitResult.h +++ b/src/base/net/stratum/SubmitResult.h @@ -37,9 +37,10 @@ class SubmitResult public: SubmitResult() = default; - inline SubmitResult(int64_t seq, uint64_t diff, uint64_t actualDiff, int64_t reqId = 0) : + inline SubmitResult(int64_t seq, uint64_t diff, uint64_t actualDiff, int64_t reqId, uint32_t backend) : reqId(reqId), seq(seq), + backend(backend), actualDiff(actualDiff), diff(diff), m_start(Chrono::steadyMSecs()) @@ -49,6 +50,7 @@ public: int64_t reqId = 0; int64_t seq = 0; + uint32_t backend = 0; uint64_t actualDiff = 0; uint64_t diff = 0; uint64_t elapsed = 0; diff --git a/src/config.json b/src/config.json index cb027a27..fbc60474 100644 --- a/src/config.json +++ b/src/config.json @@ -38,6 +38,13 @@ "cn/0": false, "cn-lite/0": false }, + "cuda": { + "enabled": false, + "loader": null, + "nvml": true, + "cn/0": false, + "cn-lite/0": false + }, "donate-level": 5, "donate-over-proxy": 1, "log-file": null, @@ -59,9 +66,10 @@ } ], "print-time": 60, + "health-print-time": 60, "retries": 5, "retry-pause": 5, "syslog": false, "user-agent": null, "watch": true -} \ No newline at end of file +} diff --git a/src/core/Miner.cpp b/src/core/Miner.cpp index 49b548e9..20ff3fd7 100644 --- a/src/core/Miner.cpp +++ b/src/core/Miner.cpp @@ -56,6 +56,11 @@ #endif +#ifdef XMRIG_FEATURE_CUDA +# include "backend/cuda/CudaBackend.h" +#endif + + #ifdef XMRIG_ALGO_RANDOMX # include "crypto/rx/RxConfig.h" #endif @@ -270,12 +275,17 @@ xmrig::Miner::Miner(Controller *controller) d_ptr->timer = new Timer(this); + d_ptr->backends.reserve(3); d_ptr->backends.push_back(new CpuBackend(controller)); # ifdef XMRIG_FEATURE_OPENCL d_ptr->backends.push_back(new OclBackend(controller)); # endif +# ifdef XMRIG_FEATURE_CUDA + d_ptr->backends.push_back(new CudaBackend(controller)); +# endif + d_ptr->rebuild(); } @@ -318,6 +328,34 @@ xmrig::Job xmrig::Miner::job() const } +void xmrig::Miner::execCommand(char command) +{ + switch (command) { + case 'h': + case 'H': + printHashrate(true); + break; + + case 'p': + case 'P': + setEnabled(false); + break; + + case 'r': + case 'R': + setEnabled(true); + break; + + default: + break; + } + + for (auto backend : d_ptr->backends) { + backend->execCommand(command); + } +} + + void xmrig::Miner::pause() { d_ptr->active = false; @@ -383,7 +421,7 @@ void xmrig::Miner::setJob(const Job &job, bool donate) } # ifdef XMRIG_ALGO_RANDOMX - if (d_ptr->algorithm.family() == Algorithm::RANDOM_X && job.algorithm().family() == Algorithm::RANDOM_X && !Rx::isReady(job)) { + if (job.algorithm().family() == Algorithm::RANDOM_X && !Rx::isReady(job)) { stop(); } # endif @@ -456,7 +494,8 @@ void xmrig::Miner::onTimer(const Timer *) d_ptr->maxHashrate[d_ptr->algorithm] = std::max(d_ptr->maxHashrate[d_ptr->algorithm], maxHashrate); - if ((d_ptr->ticks % (d_ptr->controller->config()->printTime() * 2)) == 0) { + auto seconds = d_ptr->controller->config()->printTime(); + if (seconds && (d_ptr->ticks % (seconds * 2)) == 0) { printHashrate(false); } diff --git a/src/core/Miner.h b/src/core/Miner.h index 6f4149c3..f40e37f6 100644 --- a/src/core/Miner.h +++ b/src/core/Miner.h @@ -59,6 +59,7 @@ public: const Algorithms &algorithms() const; const std::vector &backends() const; Job job() const; + void execCommand(char command); void pause(); void printHashrate(bool details); void setEnabled(bool enabled); diff --git a/src/core/config/Config.cpp b/src/core/config/Config.cpp index 7ef7197f..a445961f 100644 --- a/src/core/config/Config.cpp +++ b/src/core/config/Config.cpp @@ -48,6 +48,11 @@ #endif +#ifdef XMRIG_FEATURE_CUDA +# include "backend/cuda/CudaConfig.h" +#endif + + namespace xmrig { static const char *kCPU = "cpu"; @@ -60,6 +65,15 @@ static const char *kRandomX = "randomx"; static const char *kOcl = "opencl"; #endif +#ifdef XMRIG_FEATURE_CUDA +static const char *kCuda = "cuda"; +#endif + + +#if defined(XMRIG_FEATURE_NVML) +static const char *kHealthPrintTime = "health-print-time"; +#endif + class ConfigPrivate { @@ -73,6 +87,14 @@ public: # ifdef XMRIG_FEATURE_OPENCL OclConfig cl; # endif + +# ifdef XMRIG_FEATURE_CUDA + CudaConfig cuda; +# endif + +# if defined(XMRIG_FEATURE_NVML) + uint32_t healthPrintTime = 60; +# endif }; } @@ -104,6 +126,14 @@ const xmrig::OclConfig &xmrig::Config::cl() const #endif +#ifdef XMRIG_FEATURE_CUDA +const xmrig::CudaConfig &xmrig::Config::cuda() const +{ + return d_ptr->cuda; +} +#endif + + #ifdef XMRIG_ALGO_RANDOMX const xmrig::RxConfig &xmrig::Config::rx() const { @@ -112,6 +142,14 @@ const xmrig::RxConfig &xmrig::Config::rx() const #endif +#if defined(XMRIG_FEATURE_NVML) +uint32_t xmrig::Config::healthPrintTime() const +{ + return d_ptr->healthPrintTime; +} +#endif + + bool xmrig::Config::isShouldSave() const { if (!isAutoSave()) { @@ -124,6 +162,12 @@ bool xmrig::Config::isShouldSave() const } # endif +# ifdef XMRIG_FEATURE_CUDA + if (cuda().isShouldSave()) { + return true; + } +# endif + return (m_upgrade || cpu().isShouldSave()); } @@ -146,6 +190,14 @@ bool xmrig::Config::read(const IJsonReader &reader, const char *fileName) d_ptr->cl.read(reader.getValue(kOcl)); # endif +# ifdef XMRIG_FEATURE_CUDA + d_ptr->cuda.read(reader.getValue(kCuda)); +# endif + +# ifdef XMRIG_FEATURE_NVML + d_ptr->healthPrintTime = reader.getUint(kHealthPrintTime, d_ptr->healthPrintTime); +# endif + return true; } @@ -178,14 +230,21 @@ void xmrig::Config::getJSON(rapidjson::Document &doc) const doc.AddMember(StringRef(kOcl), cl().toJSON(doc), allocator); # endif - doc.AddMember("donate-level", m_pools.donateLevel(), allocator); - doc.AddMember("donate-over-proxy", m_pools.proxyDonate(), allocator); - doc.AddMember("log-file", m_logFile.toJSON(), allocator); - doc.AddMember("pools", m_pools.toJSON(doc), allocator); - doc.AddMember("print-time", printTime(), allocator); - doc.AddMember("retries", m_pools.retries(), allocator); - doc.AddMember("retry-pause", m_pools.retryPause(), allocator); - doc.AddMember("syslog", isSyslog(), allocator); - doc.AddMember("user-agent", m_userAgent.toJSON(), allocator); - doc.AddMember("watch", m_watch, allocator); +# ifdef XMRIG_FEATURE_CUDA + doc.AddMember(StringRef(kCuda), cuda().toJSON(doc), allocator); +# endif + + doc.AddMember("donate-level", m_pools.donateLevel(), allocator); + doc.AddMember("donate-over-proxy", m_pools.proxyDonate(), allocator); + doc.AddMember("log-file", m_logFile.toJSON(), allocator); + doc.AddMember("pools", m_pools.toJSON(doc), allocator); + doc.AddMember("print-time", printTime(), allocator); +# if defined(XMRIG_FEATURE_NVML) + doc.AddMember(StringRef(kHealthPrintTime), healthPrintTime(), allocator); +# endif + doc.AddMember("retries", m_pools.retries(), allocator); + doc.AddMember("retry-pause", m_pools.retryPause(), allocator); + doc.AddMember("syslog", isSyslog(), allocator); + doc.AddMember("user-agent", m_userAgent.toJSON(), allocator); + doc.AddMember("watch", m_watch, allocator); } diff --git a/src/core/config/Config.h b/src/core/config/Config.h index 22deb2c2..5eb91eca 100644 --- a/src/core/config/Config.h +++ b/src/core/config/Config.h @@ -39,9 +39,10 @@ namespace xmrig { class ConfigPrivate; +class CudaConfig; class IThread; -class RxConfig; class OclConfig; +class RxConfig; class Config : public BaseConfig @@ -58,10 +59,18 @@ public: const OclConfig &cl() const; # endif +# ifdef XMRIG_FEATURE_CUDA + const CudaConfig &cuda() const; +# endif + # ifdef XMRIG_ALGO_RANDOMX const RxConfig &rx() const; # endif +# if defined(XMRIG_FEATURE_NVML) + uint32_t healthPrintTime() const; +# endif + bool isShouldSave() const; bool read(const IJsonReader &reader, const char *fileName) override; void getJSON(rapidjson::Document &doc) const override; diff --git a/src/core/config/ConfigTransform.cpp b/src/core/config/ConfigTransform.cpp index ad323212..ffd3fbd8 100644 --- a/src/core/config/ConfigTransform.cpp +++ b/src/core/config/ConfigTransform.cpp @@ -47,6 +47,10 @@ static const char *kRandomX = "randomx"; static const char *kOcl = "opencl"; #endif +#ifdef XMRIG_FEATURE_CUDA +static const char *kCuda = "cuda"; +#endif + static inline uint64_t intensity(uint64_t av) { @@ -181,6 +185,22 @@ void xmrig::ConfigTransform::transform(rapidjson::Document &doc, int key, const return set(doc, kOcl, "platform", arg); # endif +# ifdef XMRIG_FEATURE_CUDA + case IConfig::CudaKey: /* --cuda */ + return set(doc, kCuda, "enabled", true); + + case IConfig::CudaLoaderKey: /* --cuda-loader */ + return set(doc, kCuda, "loader", arg); +# endif + +# ifdef XMRIG_FEATURE_NVML + case IConfig::NvmlKey: /* --no-nvml */ + return set(doc, kCuda, "nvml", false); + + case IConfig::HealthPrintTimeKey: /* --health-print-time */ + return set(doc, "health-print-time", static_cast(strtol(arg, nullptr, 10))); +# endif + default: break; } diff --git a/src/core/config/Config_default.h b/src/core/config/Config_default.h index 8a284758..afd3638b 100644 --- a/src/core/config/Config_default.h +++ b/src/core/config/Config_default.h @@ -72,6 +72,13 @@ R"===( "cn/0": false, "cn-lite/0": false }, + "cuda": { + "enabled": false, + "loader": null, + "nvml": true, + "cn/0": false, + "cn-lite/0": false + }, "donate-level": 5, "donate-over-proxy": 1, "log-file": null, @@ -93,6 +100,7 @@ R"===( } ], "print-time": 60, + "health-print-time": 60, "retries": 5, "retry-pause": 5, "syslog": false, diff --git a/src/core/config/Config_platform.h b/src/core/config/Config_platform.h index a61f1a91..3309beba 100644 --- a/src/core/config/Config_platform.h +++ b/src/core/config/Config_platform.h @@ -103,6 +103,14 @@ static const option options[] = { { "opencl-platform", 1, nullptr, IConfig::OclPlatformKey }, { "opencl-loader", 1, nullptr, IConfig::OclLoaderKey }, { "opencl-no-cache", 0, nullptr, IConfig::OclCacheKey }, +# endif +# ifdef XMRIG_FEATURE_CUDA + { "cuda", 0, nullptr, IConfig::CudaKey }, + { "cuda-loader", 1, nullptr, IConfig::CudaLoaderKey }, +# endif +# ifdef XMRIG_FEATURE_NVML + { "no-nvml", 0, nullptr, IConfig::NvmlKey }, + { "health-print-time", 1, nullptr, IConfig::HealthPrintTimeKey }, # endif { nullptr, 0, nullptr, 0 } }; diff --git a/src/core/config/usage.h b/src/core/config/usage.h index f5928fe9..d9ef2316 100644 --- a/src/core/config/usage.h +++ b/src/core/config/usage.h @@ -103,11 +103,20 @@ static inline const std::string &usage() u += " --opencl enable OpenCL mining backend\n"; u += " --opencl-devices=N list of OpenCL devices to use\n"; u += " --opencl-platform=N OpenCL platform index or name\n"; - u += " --opencl-loader=N path to OpenCL-ICD-Loader (OpenCL.dll or libOpenCL.so)\n"; + u += " --opencl-loader=PATH path to OpenCL-ICD-Loader (OpenCL.dll or libOpenCL.so)\n"; u += " --opencl-no-cache disable OpenCL cache\n"; u += " --print-platforms print available OpenCL platforms and exit\n"; # endif +# ifdef XMRIG_FEATURE_CUDA + u += "\nCUDA backend:\n"; + u += " --cuda enable CUDA mining backend\n"; + u += " --cuda-loader=PATH path to CUDA plugin (xmrig-cuda.dll or libxmrig-cuda.so)\n"; +# endif +# ifdef XMRIG_FEATURE_NVML + u += " --no-nvml disable NVML (NVIDIA Management Library) support\n"; +# endif + u += "\nLogging:\n"; # ifdef HAVE_SYSLOG_H @@ -116,6 +125,9 @@ static inline const std::string &usage() u += " -l, --log-file=FILE log all output to a file\n"; u += " --print-time=N print hashrate report every N seconds\n"; +# ifdef XMRIG_FEATURE_NVML + u += " --health-print-time=N print health report every N seconds\n"; +# endif u += " --no-color disable colored output\n"; u += "\nMisc:\n"; diff --git a/src/crypto/cn/CnAlgo.h b/src/crypto/cn/CnAlgo.h index 296c52b7..b6a76089 100644 --- a/src/crypto/cn/CnAlgo.h +++ b/src/crypto/cn/CnAlgo.h @@ -49,7 +49,7 @@ public: constexpr inline bool isR() const { return ALGO == Algorithm::CN_R; } constexpr inline size_t memory() const { static_assert(ALGO > Algorithm::INVALID && ALGO < Algorithm::RX_0, "invalid CRYPTONIGHT algorithm"); return CN_MEMORY; } constexpr inline uint32_t iterations() const { static_assert(ALGO > Algorithm::INVALID && ALGO < Algorithm::RX_0, "invalid CRYPTONIGHT algorithm"); return CN_ITER; } - constexpr inline uint32_t mask() const { return ((memory() - 1) / 16) * 16; } + constexpr inline uint32_t mask() const { return static_cast(((memory() - 1) / 16) * 16); } inline static size_t memory(Algorithm::Id algo) { diff --git a/src/crypto/common/Nonce.cpp b/src/crypto/common/Nonce.cpp index e79cb310..897045ca 100644 --- a/src/crypto/common/Nonce.cpp +++ b/src/crypto/common/Nonce.cpp @@ -48,8 +48,8 @@ xmrig::Nonce::Nonce() { m_paused = true; - for (int i = 0; i < MAX; ++i) { - m_sequence[i] = 1; + for (auto &i : m_sequence) { + i = 1; } } @@ -85,15 +85,15 @@ void xmrig::Nonce::stop() { pause(false); - for (int i = 0; i < MAX; ++i) { - m_sequence[i] = 0; + for (auto &i : m_sequence) { + i = 0; } } void xmrig::Nonce::touch() { - for (int i = 0; i < MAX; ++i) { - m_sequence[i]++; + for (auto &i : m_sequence) { + i++; } } diff --git a/src/crypto/common/Nonce.h b/src/crypto/common/Nonce.h index 401139fd..7335663d 100644 --- a/src/crypto/common/Nonce.h +++ b/src/crypto/common/Nonce.h @@ -35,7 +35,7 @@ namespace xmrig { class Nonce { public: - enum Backend { + enum Backend : uint32_t { CPU, OPENCL, CUDA, diff --git a/src/net/JobResult.h b/src/net/JobResult.h index 87bf3be9..a44a639b 100644 --- a/src/net/JobResult.h +++ b/src/net/JobResult.h @@ -47,6 +47,7 @@ public: algorithm(job.algorithm()), clientId(job.clientId()), jobId(job.id()), + backend(job.backend()), nonce(nonce), diff(job.diff()), index(job.index()) @@ -61,9 +62,10 @@ public: const Algorithm algorithm; const String clientId; const String jobId; - const uint32_t nonce = 0; - const uint64_t diff = 0; - const uint8_t index = 0; + const uint32_t backend; + const uint32_t nonce; + const uint64_t diff; + const uint8_t index; private: uint8_t m_result[32] = { 0 }; diff --git a/src/net/Network.cpp b/src/net/Network.cpp index 2fb40c6c..8c832934 100644 --- a/src/net/Network.cpp +++ b/src/net/Network.cpp @@ -34,6 +34,7 @@ #include +#include "backend/common/Tags.h" #include "base/io/log/Log.h" #include "base/net/stratum/Client.h" #include "base/net/stratum/SubmitResult.h" @@ -55,6 +56,22 @@ #endif +namespace xmrig { + + +static const char *tag = BLUE_BG_BOLD(WHITE_BOLD_S " net "); + + +} // namespace xmrig + + + +const char *xmrig::net_tag() +{ + return tag; +} + + xmrig::Network::Network(Controller *controller) : m_controller(controller), m_donate(nullptr), @@ -97,19 +114,19 @@ void xmrig::Network::connect() void xmrig::Network::onActive(IStrategy *strategy, IClient *client) { if (m_donate && m_donate == strategy) { - LOG_NOTICE("dev donate started"); + LOG_NOTICE("%s " WHITE_BOLD("dev donate started"), tag); return; } m_state.onActive(client); const char *tlsVersion = client->tlsVersion(); - LOG_INFO(WHITE_BOLD("use %s ") CYAN_BOLD("%s:%d ") GREEN_BOLD("%s") " " BLACK_BOLD("%s"), - client->mode(), client->pool().host().data(), client->pool().port(), tlsVersion ? tlsVersion : "", client->ip().data()); + LOG_INFO("%s " WHITE_BOLD("use %s ") CYAN_BOLD("%s:%d ") GREEN_BOLD("%s") " " BLACK_BOLD("%s"), + tag, client->mode(), client->pool().host().data(), client->pool().port(), tlsVersion ? tlsVersion : "", client->ip().data()); const char *fingerprint = client->tlsFingerprint(); if (fingerprint != nullptr) { - LOG_INFO(BLACK_BOLD("fingerprint (SHA-256): \"%s\""), fingerprint); + LOG_INFO("%s " BLACK_BOLD("fingerprint (SHA-256): \"%s\""), tag, fingerprint); } } @@ -178,12 +195,12 @@ void xmrig::Network::onLogin(IStrategy *, IClient *client, rapidjson::Document & void xmrig::Network::onPause(IStrategy *strategy) { if (m_donate && m_donate == strategy) { - LOG_NOTICE("dev donate finished"); + LOG_NOTICE("%s " WHITE_BOLD("dev donate finished"), tag); m_strategy->resume(); } if (!m_strategy->isActive()) { - LOG_ERR("no active pools, stop mining"); + LOG_ERR("%s " RED("no active pools, stop mining"), tag); m_state.stop(); return m_controller->miner()->pause(); @@ -196,12 +213,12 @@ void xmrig::Network::onResultAccepted(IStrategy *, IClient *, const SubmitResult m_state.add(result, error); if (error) { - LOG_INFO(RED_BOLD("rejected") " (%" PRId64 "/%" PRId64 ") diff " WHITE_BOLD("%" PRIu64) " " RED("\"%s\"") " " BLACK_BOLD("(%" PRIu64 " ms)"), - m_state.accepted, m_state.rejected, result.diff, error, result.elapsed); + LOG_INFO("%s " RED_BOLD("rejected") " (%" PRId64 "/%" PRId64 ") diff " WHITE_BOLD("%" PRIu64) " " RED("\"%s\"") " " BLACK_BOLD("(%" PRIu64 " ms)"), + backend_tag(result.backend), m_state.accepted, m_state.rejected, result.diff, error, result.elapsed); } else { - LOG_INFO(GREEN_BOLD("accepted") " (%" PRId64 "/%" PRId64 ") diff " WHITE_BOLD("%" PRIu64) " " BLACK_BOLD("(%" PRIu64 " ms)"), - m_state.accepted, m_state.rejected, result.diff, result.elapsed); + LOG_INFO("%s " GREEN_BOLD("accepted") " (%" PRId64 "/%" PRId64 ") diff " WHITE_BOLD("%" PRIu64) " " BLACK_BOLD("(%" PRIu64 " ms)"), + backend_tag(result.backend), m_state.accepted, m_state.rejected, result.diff, result.elapsed); } } @@ -232,12 +249,12 @@ void xmrig::Network::onRequest(IApiRequest &request) void xmrig::Network::setJob(IClient *client, const Job &job, bool donate) { if (job.height()) { - LOG_INFO(MAGENTA_BOLD("new job") " from " WHITE_BOLD("%s:%d") " diff " WHITE_BOLD("%" PRIu64) " algo " WHITE_BOLD("%s") " height " WHITE_BOLD("%" PRIu64), - client->pool().host().data(), client->pool().port(), job.diff(), job.algorithm().shortName(), job.height()); + LOG_INFO("%s " MAGENTA_BOLD("new job") " from " WHITE_BOLD("%s:%d") " diff " WHITE_BOLD("%" PRIu64) " algo " WHITE_BOLD("%s") " height " WHITE_BOLD("%" PRIu64), + tag, client->pool().host().data(), client->pool().port(), job.diff(), job.algorithm().shortName(), job.height()); } else { - LOG_INFO(MAGENTA_BOLD("new job") " from " WHITE_BOLD("%s:%d") " diff " WHITE_BOLD("%" PRIu64) " algo " WHITE_BOLD("%s"), - client->pool().host().data(), client->pool().port(), job.diff(), job.algorithm().shortName()); + LOG_INFO("%s " MAGENTA_BOLD("new job") " from " WHITE_BOLD("%s:%d") " diff " WHITE_BOLD("%" PRIu64) " algo " WHITE_BOLD("%s"), + tag, client->pool().host().data(), client->pool().port(), job.diff(), job.algorithm().shortName()); } if (!donate && m_donate) { diff --git a/src/version.h b/src/version.h index dab33f9d..ea5c458c 100644 --- a/src/version.h +++ b/src/version.h @@ -28,14 +28,14 @@ #define APP_ID "xmrig" #define APP_NAME "XMRig" #define APP_DESC "XMRig miner" -#define APP_VERSION "4.4.0-beta" +#define APP_VERSION "4.5.0-evo" #define APP_DOMAIN "xmrig.com" #define APP_SITE "www.xmrig.com" #define APP_COPYRIGHT "Copyright (C) 2016-2019 xmrig.com" #define APP_KIND "miner" #define APP_VER_MAJOR 4 -#define APP_VER_MINOR 4 +#define APP_VER_MINOR 5 #define APP_VER_PATCH 0 #ifdef _MSC_VER