Ecosystem/xmrig
Ecosystem/xmrig
1
0
Fork 0
mirror of https://github.com/xmrig/xmrig.git synced 2025-02-02 03:06:30 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'feature-nvml' into evo

Browse source
This commit is contained in:
XMRig 2019-11-01 04:09:36 +07:00
commit be31811920
30 changed files with 698 additions and 60 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
CMakeLists.txt
View file

@ -16,6 +16,7 @@ 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)

2
README.md
View file

@ -84,11 +84,13 @@ OpenCL backend:
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:

25
src/App.cpp
View file

@ -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);
}
}

6
src/Summary.cpp
View file

@ -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");

1
src/backend/common/interfaces/IBackend.h
View file

@ -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;

2
src/backend/cpu/CpuBackend.h
View file

@ -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;

109
src/backend/cuda/CudaBackend.cpp
View file

@ -51,6 +51,13 @@
#endif
#ifdef XMRIG_FEATURE_NVML
#include "backend/cuda/wrappers/NvmlLib.h"
namespace xmrig { static const char *kNvmlLabel = "NVML"; }
#endif
namespace xmrig {
@ -58,15 +65,16 @@ extern template class Threads<CudaThreads>;
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 *reason)
static void printDisabled(const char *label, const char *reason)
{
Log::print(GREEN_BOLD(" * ") WHITE_BOLD("%-13s") RED_BOLD("disabled") "%s", "CUDA", reason);
Log::print(GREEN_BOLD(" * ") WHITE_BOLD("%-13s") RED_BOLD("disabled") "%s", label, reason);
}
@ -129,29 +137,49 @@ public:
void init(const CudaConfig &cuda)
{
if (!cuda.isEnabled()) {
return printDisabled("");
return printDisabled(kLabel, "");
}
if (!CudaLib::init(cuda.loader())) {
return printDisabled(RED_S " (failed to load CUDA plugin)");
return printDisabled(kLabel, RED_S " (failed to load CUDA plugin)");
}
runtimeVersion = CudaLib::runtimeVersion();
driverVersion = CudaLib::driverVersion();
if (!runtimeVersion || !driverVersion || !CudaLib::deviceCount()) {
return printDisabled(RED_S " (no devices)");
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"), "CUDA",
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",
@ -205,6 +233,38 @@ public:
}
# 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;
@ -238,6 +298,10 @@ xmrig::CudaBackend::~CudaBackend()
delete d_ptr;
CudaLib::close();
# ifdef XMRIG_FEATURE_NVML
NvmlLib::close();
# endif
}
@ -271,6 +335,16 @@ const xmrig::String &xmrig::CudaBackend::type() const
}
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 &)
{
}
@ -378,6 +452,13 @@ void xmrig::CudaBackend::stop()
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
}
@ -394,10 +475,18 @@ rapidjson::Value xmrig::CudaBackend::toJSON(rapidjson::Document &doc) const
out.AddMember("profile", profileName().toJSON(), allocator);
Value versions(kObjectType);
versions.AddMember("runtime", Value(CudaLib::version(d_ptr->runtimeVersion).c_str(), allocator), allocator);
versions.AddMember("driver", Value(CudaLib::version(d_ptr->driverVersion).c_str(), allocator), allocator);
versions.AddMember("plugin", String(CudaLib::pluginVersion()).toJSON(doc), allocator);
out.AddMember("versions", versions, allocator);
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;

1
src/backend/cuda/CudaBackend.h
View file

@ -56,6 +56,7 @@ protected:
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;

23
src/backend/cuda/CudaConfig.cpp
View file

@ -40,6 +40,10 @@ 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<CudaThreads>;
@ -57,6 +61,15 @@ rapidjson::Value xmrig::CudaConfig::toJSON(rapidjson::Document &doc) const
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;
@ -95,6 +108,16 @@ void xmrig::CudaConfig::read(const rapidjson::Value &value)
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();

10
src/backend/cuda/CudaConfig.h
View file

@ -50,6 +50,11 @@ public:
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);
@ -67,6 +72,11 @@ private:
int32_t m_bfactor = 0;
int32_t m_bsleep = 0;
# endif
# ifdef XMRIG_FEATURE_NVML
bool m_nvml = true;
String m_nvmlLoader;
# endif
};

15
src/backend/cuda/cuda.cmake
View file

@ -30,8 +30,23 @@ if (WITH_CUDA)
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 "")

23
src/backend/cuda/wrappers/CudaDevice.cpp
View file

@ -30,6 +30,9 @@
#include "crypto/common/Algorithm.h"
#include "rapidjson/document.h"
#ifdef XMRIG_FEATURE_NVML
# include "backend/cuda/wrappers/NvmlLib.h"
#endif
#include <algorithm>
@ -125,5 +128,25 @@ void xmrig::CudaDevice::toJSON(rapidjson::Value &out, rapidjson::Document &doc)
out.AddMember("global_mem", static_cast<uint64_t>(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

22
src/backend/cuda/wrappers/CudaDevice.h
View file

@ -30,7 +30,8 @@
#include "base/tools/String.h"
using nvid_ctx = struct nvid_ctx;
using nvid_ctx = struct nvid_ctx;
using nvmlDevice_t = struct nvmlDevice_st *;
namespace xmrig {
@ -57,11 +58,16 @@ public:
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; }
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;
@ -75,6 +81,10 @@ private:
nvid_ctx *m_ctx = nullptr;
PciTopology m_topology;
String m_name;
# ifdef XMRIG_FEATURE_NVML
nvmlDevice_t m_nvmlDevice = nullptr;
# endif
};

1
src/backend/cuda/wrappers/CudaLib.cpp
View file

@ -28,7 +28,6 @@
#include "backend/cuda/wrappers/CudaLib.h"
#include "base/io/log/Log.h"
namespace xmrig {

43
src/backend/cuda/wrappers/NvmlHealth.h Normal file
View file

@ -0,0 +1,43 @@
/* XMRig
* Copyright 2010 Jeff Garzik <jgarzik@pobox.com>
* Copyright 2012-2014 pooler <pooler@litecoinpool.org>
* Copyright 2014 Lucas Jones <https://github.com/lucasjones>
* Copyright 2014-2016 Wolf9466 <https://github.com/OhGodAPet>
* Copyright 2016 Jay D Dee <jayddee246@gmail.com>
* Copyright 2017-2018 XMR-Stak <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
* Copyright 2018-2019 SChernykh <https://github.com/SChernykh>
* Copyright 2016-2019 XMRig <https://github.com/xmrig>, <support@xmrig.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef XMRIG_NVMLHEALTH_H
#define XMRIG_NVMLHEALTH_H
#include <cstdint>
#include <vector>
struct NvmlHealth
{
std::vector<uint32_t> fanSpeed;
uint32_t clock = 0;
uint32_t memClock = 0;
uint32_t power = 0;
uint32_t temperature = 0;
};
#endif /* XMRIG_NVMLHEALTH_H */

227
src/backend/cuda/wrappers/NvmlLib.cpp Normal file
View file

@ -0,0 +1,227 @@
/* XMRig
* Copyright 2010 Jeff Garzik <jgarzik@pobox.com>
* Copyright 2012-2014 pooler <pooler@litecoinpool.org>
* Copyright 2014 Lucas Jones <https://github.com/lucasjones>
* Copyright 2014-2016 Wolf9466 <https://github.com/OhGodAPet>
* Copyright 2016 Jay D Dee <jayddee246@gmail.com>
* Copyright 2017-2018 XMR-Stak <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
* Copyright 2018-2019 SChernykh <https://github.com/SChernykh>
* Copyright 2016-2019 XMRig <https://github.com/xmrig>, <support@xmrig.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdexcept>
#include <uv.h>
#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<void**>(&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<CudaDevice> &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<void**>(&pNvmlDeviceGetFanSpeed_v2));
if (pNvmlInit() != NVML_SUCCESS) {
return false;
}
pNvmlSystemGetDriverVersion(m_driverVersion, sizeof(m_driverVersion));
pNvmlSystemGetNVMLVersion(m_nvmlVersion, sizeof(m_nvmlVersion));
return true;
}

66
src/backend/cuda/wrappers/NvmlLib.h Normal file
View file

@ -0,0 +1,66 @@
/* XMRig
* Copyright 2010 Jeff Garzik <jgarzik@pobox.com>
* Copyright 2012-2014 pooler <pooler@litecoinpool.org>
* Copyright 2014 Lucas Jones <https://github.com/lucasjones>
* Copyright 2014-2016 Wolf9466 <https://github.com/OhGodAPet>
* Copyright 2016 Jay D Dee <jayddee246@gmail.com>
* Copyright 2017-2018 XMR-Stak <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
* Copyright 2018-2019 SChernykh <https://github.com/SChernykh>
* Copyright 2016-2019 XMRig <https://github.com/xmrig>, <support@xmrig.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#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<CudaDevice> &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 */

55
src/backend/cuda/wrappers/nvml_lite.h Normal file
View file

@ -0,0 +1,55 @@
/* XMRig
* Copyright 2010 Jeff Garzik <jgarzik@pobox.com>
* Copyright 2012-2014 pooler <pooler@litecoinpool.org>
* Copyright 2014 Lucas Jones <https://github.com/lucasjones>
* Copyright 2014-2016 Wolf9466 <https://github.com/OhGodAPet>
* Copyright 2016 Jay D Dee <jayddee246@gmail.com>
* Copyright 2017-2018 XMR-Stak <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
* Copyright 2018-2019 SChernykh <https://github.com/SChernykh>
* Copyright 2016-2019 XMRig <https://github.com/xmrig>, <support@xmrig.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef XMRIG_NVML_LITE_H
#define XMRIG_NVML_LITE_H
#include <cstdint>
#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 */

2
src/backend/opencl/OclBackend.h
View file

@ -51,6 +51,8 @@ public:
~OclBackend() override;
protected:
inline void execCommand(char) override {}
bool isEnabled() const override;
bool isEnabled(const Algorithm &algorithm) const override;
const Hashrate *hashrate() const override;

4
src/base/kernel/interfaces/IConfig.h
View file

@ -135,7 +135,9 @@ public:
CudaAffinityKey = 1205,
CudaMaxUsageKey = 1206,
CudaKey = 1207,
CudaLoaderKey = 1208
CudaLoaderKey = 1208,
NvmlKey = 1209,
HealthPrintTimeKey = 1210,
};
virtual ~IConfig() = default;

4
src/config.json
View file

@ -41,6 +41,9 @@
"cuda": {
"enabled": false,
"loader": null,
"nvml": true,
"cn/0": false,
"cn-lite/0": false
},
"donate-level": 5,
"donate-over-proxy": 1,
@ -63,6 +66,7 @@
}
],
"print-time": 60,
"health-print-time": 60,
"retries": 5,
"retry-pause": 5,
"syslog": false,

33
src/core/Miner.cpp
View file

@ -328,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;
@ -393,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
@ -466,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);
}

1
src/core/Miner.h
View file

@ -59,6 +59,7 @@ public:
const Algorithms &algorithms() const;
const std::vector<IBackend *> &backends() const;
Job job() const;
void execCommand(char command);
void pause();
void printHashrate(bool details);
void setEnabled(bool enabled);

44
src/core/config/Config.cpp
View file

@ -70,6 +70,11 @@ static const char *kCuda = "cuda";
#endif
#if defined(XMRIG_FEATURE_NVML)
static const char *kHealthPrintTime = "health-print-time";
#endif
class ConfigPrivate
{
public:
@ -86,6 +91,10 @@ public:
# ifdef XMRIG_FEATURE_CUDA
CudaConfig cuda;
# endif
# if defined(XMRIG_FEATURE_NVML)
uint32_t healthPrintTime = 60;
# endif
};
}
@ -133,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()) {
@ -177,6 +194,10 @@ bool xmrig::Config::read(const IJsonReader &reader, const char *fileName)
d_ptr->cuda.read(reader.getValue(kCuda));
# endif
# ifdef XMRIG_FEATURE_NVML
d_ptr->healthPrintTime = reader.getUint(kHealthPrintTime, d_ptr->healthPrintTime);
# endif
return true;
}
@ -213,14 +234,17 @@ void xmrig::Config::getJSON(rapidjson::Document &doc) const
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);
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);
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);
}

4
src/core/config/Config.h
View file

@ -67,6 +67,10 @@ public:
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;

8
src/core/config/ConfigTransform.cpp
View file

@ -193,6 +193,14 @@ void xmrig::ConfigTransform::transform(rapidjson::Document &doc, int key, const
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<uint64_t>(strtol(arg, nullptr, 10)));
# endif
default:
break;
}

4
src/core/config/Config_default.h
View file

@ -75,6 +75,9 @@ R"===(
"cuda": {
"enabled": false,
"loader": null,
"nvml": true,
"cn/0": false,
"cn-lite/0": false
},
"donate-level": 5,
"donate-over-proxy": 1,
@ -97,6 +100,7 @@ R"===(
}
],
"print-time": 60,
"health-print-time": 60,
"retries": 5,
"retry-pause": 5,
"syslog": false,

4
src/core/config/Config_platform.h
View file

@ -107,6 +107,10 @@ static const option options[] = {
# 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 }
};

6
src/core/config/usage.h
View file

@ -113,6 +113,9 @@ static inline const std::string &usage()
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";
@ -122,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";

12
src/crypto/common/Nonce.cpp
View file

@ -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++;
}
}