Merge 14128cbdb4 into 16ecb8f085

CUDA backend: update RandomX dataset when it changes

src/backend/cpu/interfaces/ICpuInfo.h

@@ -29,6 +29,10 @@
 #ifdef XMRIG_FEATURE_HWLOC
 using hwloc_const_bitmap_t  = const struct hwloc_bitmap_s *;
 using hwloc_topology_t      = struct hwloc_topology *;
+#define MEMBIND_SUCCESS    1
+#define MEMBIND_FAIL_SUPP -1
+#define MEMBIND_FAIL_NODE -2
+#define MEMBIND_FAIL_BIND -3
 #endif
 
 
@@ -126,7 +130,7 @@ public:
     virtual uint32_t model() const                                                  = 0;
 
 #   ifdef XMRIG_FEATURE_HWLOC
-    virtual bool membind(hwloc_const_bitmap_t nodeset)                              = 0;
+    virtual int8_t membind(hwloc_const_bitmap_t nodeset)                            = 0;
     virtual const std::vector<uint32_t> &nodeset() const                            = 0;
     virtual hwloc_topology_t topology() const                                       = 0;
 #   endif

src/backend/cpu/platform/HwlocCpuInfo.cpp

@@ -23,6 +23,7 @@
 
 #include <algorithm>
 #include <cmath>
+#include <errno.h>
 #include <hwloc.h>
 
 
@@ -191,16 +192,25 @@ xmrig::HwlocCpuInfo::~HwlocCpuInfo()
 }
 
 
-bool xmrig::HwlocCpuInfo::membind(hwloc_const_bitmap_t nodeset)
+int8_t xmrig::HwlocCpuInfo::membind(hwloc_const_bitmap_t nodeset)
 {
     if (!hwloc_topology_get_support(m_topology)->membind->set_thisthread_membind) {
-        return false;
+        return MEMBIND_FAIL_SUPP;
     }
 
 #   if HWLOC_API_VERSION >= 0x20000
-    return hwloc_set_membind(m_topology, nodeset, HWLOC_MEMBIND_BIND, HWLOC_MEMBIND_THREAD | HWLOC_MEMBIND_BYNODESET) >= 0;
+    int rv = hwloc_set_membind(m_topology, nodeset, HWLOC_MEMBIND_BIND, HWLOC_MEMBIND_THREAD | HWLOC_MEMBIND_BYNODESET);
+    int error = errno;
+
+    if (rv < 0) {
+        LOG_WARN("hwloc_set_membind() error: \"%s\"\n", strerror(error));
+        return MEMBIND_FAIL_BIND;
+    }
+
+    return MEMBIND_SUCCESS;
 #   else
-    return hwloc_set_membind_nodeset(m_topology, nodeset, HWLOC_MEMBIND_BIND, HWLOC_MEMBIND_THREAD) >= 0;
+    return (hwloc_set_membind_nodeset(m_topology, nodeset, HWLOC_MEMBIND_BIND, HWLOC_MEMBIND_THREAD) >= 0)
+        ? MEMBIND_SUCCESS : MEMBIND_FAIL_BIND;
 #   endif
 }
 

src/backend/cpu/platform/HwlocCpuInfo.h

@@ -38,7 +38,7 @@ public:
     ~HwlocCpuInfo() override;
 
 protected:
-    bool membind(hwloc_const_bitmap_t nodeset) override;
+    int8_t membind(hwloc_const_bitmap_t nodeset) override;
     CpuThreads threads(const Algorithm &algorithm, uint32_t limit) const override;
 
     inline const char *backend() const override                     { return m_backend; }

src/backend/cuda/runners/CudaRxRunner.cpp

@@ -5,8 +5,8 @@
  * 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 2018-2024 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright 2016-2024 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
@@ -22,7 +22,6 @@
  *   along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include "backend/cuda/runners/CudaRxRunner.h"
 #include "backend/cuda/CudaLaunchData.h"
 #include "backend/cuda/wrappers/CudaLib.h"
@@ -55,12 +54,21 @@ bool xmrig::CudaRxRunner::run(uint32_t startNonce, uint32_t *rescount, uint32_t
 
 bool xmrig::CudaRxRunner::set(const Job &job, uint8_t *blob)
 {
+    if (!m_datasetHost && (m_seed != job.seed())) {
+        m_seed = job.seed();
+
+        if (m_ready) {
+            const auto *dataset = Rx::dataset(job, 0);
+            callWrapper(CudaLib::rxUpdateDataset(m_ctx, dataset->raw(), dataset->size(false)));
+        }
+    }
+
     const bool rc = CudaBaseRunner::set(job, blob);
     if (!rc || m_ready) {
         return rc;
     }
 
-    auto dataset = Rx::dataset(job, 0);
+    const auto *dataset = Rx::dataset(job, 0);
     m_ready = callWrapper(CudaLib::rxPrepare(m_ctx, dataset->raw(), dataset->size(false), m_datasetHost, m_intensity));
 
     return m_ready;

src/backend/cuda/runners/CudaRxRunner.h

@@ -5,8 +5,8 @@
  * 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 2018-2024 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright 2016-2024 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
@@ -27,6 +27,7 @@
 
 
 #include "backend/cuda/runners/CudaBaseRunner.h"
+#include "base/tools/Buffer.h"
 
 
 namespace xmrig {
@@ -46,6 +47,7 @@ protected:
 private:
     bool m_ready             = false;
     const bool m_datasetHost = false;
+    Buffer m_seed;
     size_t m_intensity       = 0;
 };
 

src/backend/cuda/wrappers/CudaLib.cpp

@@ -19,10 +19,10 @@
 #include <stdexcept>
 #include <uv.h>
 
-
 #include "backend/cuda/wrappers/CudaLib.h"
 #include "base/io/Env.h"
 #include "base/io/log/Log.h"
+#include "base/io/log/Tags.h"
 #include "base/kernel/Process.h"
 #include "crypto/rx/RxAlgo.h"
 
@@ -68,6 +68,7 @@ static const char *kPluginVersion                       = "pluginVersion";
 static const char *kRelease                             = "release";
 static const char *kRxHash                              = "rxHash";
 static const char *kRxPrepare                           = "rxPrepare";
+static const char *kRxUpdateDataset                     = "rxUpdateDataset";
 static const char *kSetJob                              = "setJob";
 static const char *kSetJob_v2                           = "setJob_v2";
 static const char *kVersion                             = "version";
@@ -92,6 +93,7 @@ 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, bool, uint32_t);
+using rxUpdateDataset_t                                 = bool (*)(nvid_ctx *, const void *, size_t);
 using setJob_t                                          = bool (*)(nvid_ctx *, const void *, size_t, uint32_t);
 using setJob_v2_t                                       = bool (*)(nvid_ctx *, const void *, size_t, const char *);
 using version_t                                         = uint32_t (*)(Version);
@@ -116,6 +118,7 @@ static pluginVersion_t pPluginVersion                   = nullptr;
 static release_t pRelease                               = nullptr;
 static rxHash_t pRxHash                                 = nullptr;
 static rxPrepare_t pRxPrepare                           = nullptr;
+static rxUpdateDataset_t pRxUpdateDataset               = nullptr;
 static setJob_t pSetJob                                 = nullptr;
 static setJob_v2_t pSetJob_v2                           = nullptr;
 static version_t pVersion                               = nullptr;
@@ -202,10 +205,26 @@ bool xmrig::CudaLib::rxHash(nvid_ctx *ctx, uint32_t startNonce, uint64_t target,
 
 bool xmrig::CudaLib::rxPrepare(nvid_ctx *ctx, const void *dataset, size_t datasetSize, bool dataset_host, uint32_t batchSize) noexcept
 {
+#   ifdef XMRIG_ALGO_RANDOMX
+    if (!pRxUpdateDataset) {
+        LOG_WARN("%s" YELLOW_BOLD("CUDA plugin is outdated. Please update to the latest version"), Tags::randomx());
+    }
+#   endif
+
     return pRxPrepare(ctx, dataset, datasetSize, dataset_host, batchSize);
 }
 
 
+bool xmrig::CudaLib::rxUpdateDataset(nvid_ctx *ctx, const void *dataset, size_t datasetSize) noexcept
+{
+    if (pRxUpdateDataset) {
+        return pRxUpdateDataset(ctx, dataset, datasetSize);
+    }
+
+    return true;
+}
+
+
 bool xmrig::CudaLib::kawPowHash(nvid_ctx *ctx, uint8_t* job_blob, uint64_t target, uint32_t *rescount, uint32_t *resnonce, uint32_t *skipped_hashes) noexcept
 {
     return pKawPowHash(ctx, job_blob, target, rescount, resnonce, skipped_hashes);
@@ -401,5 +420,7 @@ void xmrig::CudaLib::load()
         DLSYM(SetJob_v2);
     }
 
+    uv_dlsym(&cudaLib, kRxUpdateDataset, reinterpret_cast<void**>(&pRxUpdateDataset));
+
     pInit();
 }

src/backend/cuda/wrappers/CudaLib.h

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2018-2024 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2016-2024 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
@@ -71,6 +71,7 @@ public:
     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, bool dataset_host, uint32_t batchSize) noexcept;
+    static bool rxUpdateDataset(nvid_ctx *ctx, const void *dataset, size_t datasetSize) noexcept;
     static bool kawPowHash(nvid_ctx *ctx, uint8_t* job_blob, uint64_t target, uint32_t *rescount, uint32_t *resnonce, uint32_t *skipped_hashes) noexcept;
     static bool kawPowPrepare(nvid_ctx *ctx, const void* cache, size_t cache_size, const void* dag_precalc, size_t dag_size, uint32_t height, const uint64_t* dag_sizes) noexcept;
     static bool kawPowStopHash(nvid_ctx *ctx) noexcept;

src/crypto/common/VirtualMemory_hwloc.cpp

@@ -34,8 +34,13 @@ uint32_t xmrig::VirtualMemory::bindToNUMANode(int64_t affinity)
 
     auto pu = hwloc_get_pu_obj_by_os_index(Cpu::info()->topology(), static_cast<unsigned>(affinity));
 
-    if (pu == nullptr || !Cpu::info()->membind(pu->nodeset)) {
+    if (pu == nullptr) {
-        LOG_WARN("CPU #%02" PRId64 " warning: \"can't bind memory\"", affinity);
+        LOG_WARN("CPU #%02" PRId64 " warning: \"can't bind memory: hwloc_get_pu_obj_by_os_index() failed\"", affinity);
+
+        return 0;
+    }
+    if (Cpu::info()->membind(pu->nodeset) < 0) {
+        LOG_WARN("CPU #%02" PRId64 " warning: \"can't bind memory: Cpu::info()->membind() failed\"", affinity);
 
         return 0;
     }

src/crypto/rx/RxBasicStorage.cpp

@@ -1,7 +1,7 @@
 /* XMRig
  * Copyright (c) 2018-2019 tevador     <tevador@gmail.com>
- * Copyright (c) 2018-2020 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2018-2024 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2016-2024 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
@@ -17,9 +17,7 @@
  *   along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include "crypto/rx/RxBasicStorage.h"
-#include "backend/common/Tags.h"
 #include "base/io/log/Log.h"
 #include "base/io/log/Tags.h"
 #include "base/tools/Chrono.h"

src/crypto/rx/RxNUMAStorage.cpp

@@ -42,20 +42,20 @@ constexpr size_t oneMiB = 1024 * 1024;
 static std::mutex mutex;
 
 
-static bool bindToNUMANode(uint32_t nodeId)
+static int8_t bindToNUMANode(uint32_t nodeId)
 {
     auto node = hwloc_get_numanode_obj_by_os_index(Cpu::info()->topology(), nodeId);
     if (!node) {
-        return false;
+        return MEMBIND_FAIL_NODE;
     }
 
-    if (Cpu::info()->membind(node->nodeset)) {
+    if (Cpu::info()->membind(node->nodeset) > 0) {
         Platform::setThreadAffinity(static_cast<uint64_t>(hwloc_bitmap_first(node->cpuset)));
 
-        return true;
+        return MEMBIND_SUCCESS;
     }
 
-    return false;
+    return MEMBIND_FAIL_BIND;
 }
 
 
@@ -210,10 +210,20 @@ private:
     static void allocate(RxNUMAStoragePrivate *d_ptr, uint32_t nodeId, bool hugePages, bool oneGbPages)
     {
         const uint64_t ts = Chrono::steadyMSecs();
+        const int8_t   br = bindToNUMANode(nodeId);
 
-        if (!bindToNUMANode(nodeId)) {
+        if (br < 0) {
-            printSkipped(nodeId, "can't bind memory");
+            switch (br) {
-
+            case MEMBIND_FAIL_SUPP:
+                printSkipped(nodeId, "can't bind memory: hwloc_topology_get_support() failed");
+                break;
+            case MEMBIND_FAIL_NODE:
+                printSkipped(nodeId, "can't bind memory: hwloc_get_numanode_obj_by_os_index() failed");
+                break;
+            case MEMBIND_FAIL_BIND:
+                printSkipped(nodeId, "can't bind memory: Cpu::info()->membind() failed");
+                break;
+            }
             return;
         }