Added RandomX support.

src/backend/cuda/runners/CudaBaseRunner.cpp

@@ -51,13 +51,7 @@ bool xmrig::CudaBaseRunner::init()
         return false;
     }
 
-    if (!CudaLib::deviceInit(m_ctx)) {
-        printError(CudaLib::lastError(m_ctx));
-
-        return false;
-    }
-
-    return true;
+    return callWrapper(CudaLib::deviceInit(m_ctx));
 }
 
 
@@ -66,13 +60,7 @@ bool xmrig::CudaBaseRunner::set(const Job &job, uint8_t *blob)
     m_height = job.height();
     m_target = job.target();
 
-    if (!CudaLib::setJob(m_ctx, blob, job.size(), job.algorithm())) {
-        printError(CudaLib::lastError(m_ctx));
-
-        return false;
-    }
-
-    return true;
+    return callWrapper(CudaLib::setJob(m_ctx, blob, job.size(), job.algorithm()));
 }
 
 
@@ -82,9 +70,14 @@ size_t xmrig::CudaBaseRunner::intensity() const
 }
 
 
-void xmrig::CudaBaseRunner::printError(const char *error) const
+bool xmrig::CudaBaseRunner::callWrapper(bool result) const
 {
-    if (error) {
-        LOG_ERR("%s" RED_S " thread " RED_BOLD("#%zu") RED_S " failed with error " RED_BOLD("%s"), cuda_tag(), m_threadId, error);
+    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;
 }

src/backend/cuda/runners/CudaBaseRunner.h

@@ -52,7 +52,7 @@ protected:
     size_t intensity() const override;
 
 protected:
-    void printError(const char *error) const;
+    bool callWrapper(bool result) const;
 
     const CudaLaunchData &m_data;
     const size_t m_threadId;

src/backend/cuda/runners/CudaCnRunner.cpp

@@ -34,11 +34,5 @@ xmrig::CudaCnRunner::CudaCnRunner(size_t index, const CudaLaunchData &data) : Cu
 
 bool xmrig::CudaCnRunner::run(uint32_t startNonce, uint32_t *rescount, uint32_t *resnonce)
 {
-    if (!CudaLib::cnHash(m_ctx, startNonce, m_height, m_target, rescount, resnonce)) {
-        printError(CudaLib::lastError(m_ctx));
-
-        return false;
-    }
-
-    return true;
+    return callWrapper(CudaLib::cnHash(m_ctx, startNonce, m_height, m_target, rescount, resnonce));
 }

src/backend/cuda/runners/CudaRxRunner.cpp

@@ -24,19 +24,42 @@
 
 
 #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;
+    }
 
-xmrig::CudaRxRunner::~CudaRxRunner()
-{
+    m_intensity -= m_intensity % 32;
 }
 
 
 bool xmrig::CudaRxRunner::run(uint32_t startNonce, uint32_t *rescount, uint32_t *resnonce)
 {
-    return false;
+    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;
 }

src/backend/cuda/runners/CudaRxRunner.h

@@ -35,15 +35,17 @@ namespace xmrig {
 class CudaRxRunner : public CudaBaseRunner
 {
 public:
-    XMRIG_DISABLE_COPY_MOVE_DEFAULT(CudaRxRunner)
-
     CudaRxRunner(size_t index, const CudaLaunchData &data);
-    ~CudaRxRunner() override;
 
 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;
 };