KawPow WIP

src/backend/cuda/CudaConfig.cpp

@@ -181,6 +181,7 @@ void xmrig::CudaConfig::generate()
     count += xmrig::generate<Algorithm::CN_PICO>(m_threads, devices);
     count += xmrig::generate<Algorithm::RANDOM_X>(m_threads, devices);
     count += xmrig::generate<Algorithm::ASTROBWT>(m_threads, devices);
+    count += xmrig::generate<Algorithm::KAWPOW>(m_threads, devices);
 
     generated    = true;
     m_shouldSave = count > 0;

src/backend/cuda/CudaConfig_gen.h

@@ -64,10 +64,6 @@ size_t inline generate<Algorithm::CN>(Threads<CudaThreads> &threads, const std::
         count++;
     }
 
-#   ifdef XMRIG_ALGO_CN_GPU
-    count += generate("cn/gpu", threads, Algorithm::CN_GPU, devices);
-#   endif
-
     return count;
 }
 
@@ -145,6 +141,15 @@ size_t inline generate<Algorithm::ASTROBWT>(Threads<CudaThreads> &threads, const
 #endif
 
 
+#ifdef XMRIG_ALGO_KAWPOW
+template<>
+size_t inline generate<Algorithm::KAWPOW>(Threads<CudaThreads> &threads, const std::vector<CudaDevice> &devices)
+{
+    return generate("kawpow", threads, Algorithm::KAWPOW_RVN, devices);
+}
+#endif
+
+
 } /* namespace xmrig */
 
 

src/backend/cuda/CudaWorker.cpp

@@ -44,6 +44,11 @@
 #endif
 
 
+#ifdef XMRIG_ALGO_KAWPOW
+#   include "backend/cuda/runners/CudaKawPowRunner.h"
+#endif
+
+
 #include <cassert>
 #include <thread>
 
@@ -84,6 +89,12 @@ xmrig::CudaWorker::CudaWorker(size_t id, const CudaLaunchData &data) :
 #       endif
         break;
 
+    case Algorithm::KAWPOW:
+#       ifdef XMRIG_ALGO_KAWPOW
+        m_runner = new CudaKawPowRunner(id, data);
+#       endif
+        break;
+
     default:
         m_runner = new CudaCnRunner(id, data);
         break;
@@ -138,7 +149,7 @@ void xmrig::CudaWorker::start()
         }
 
         while (!Nonce::isOutdated(Nonce::CUDA, m_job.sequence())) {
-            uint32_t foundNonce[10] = { 0 };
+            uint32_t foundNonce[16] = { 0 };
             uint32_t foundCount     = 0;
 
             if (!m_runner->run(*m_job.nonce(), &foundCount, foundNonce)) {
@@ -150,7 +161,7 @@ void xmrig::CudaWorker::start()
             }
 
             const size_t batch_size = intensity();
-            if (!m_job.nextRound(roundSize(batch_size), batch_size)) {
+            if (!Nonce::isOutdated(Nonce::CUDA, m_job.sequence()) && !m_job.nextRound(roundSize(batch_size), batch_size)) {
                 JobResults::done(m_job.currentJob());
             }
 
@@ -174,7 +185,7 @@ bool xmrig::CudaWorker::consumeJob()
     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());;
+    return m_runner->set(m_job.currentJob(), m_job.blob());
 }
 
 

src/backend/cuda/cuda.cmake

@@ -52,6 +52,11 @@ if (WITH_CUDA)
        list(APPEND HEADERS_BACKEND_CUDA src/backend/cuda/runners/CudaAstroBWTRunner.h)
        list(APPEND SOURCES_BACKEND_CUDA src/backend/cuda/runners/CudaAstroBWTRunner.cpp)
    endif()
+
+   if (WITH_KAWPOW)
+       list(APPEND HEADERS_BACKEND_CUDA src/backend/cuda/runners/CudaKawPowRunner.h)
+       list(APPEND SOURCES_BACKEND_CUDA src/backend/cuda/runners/CudaKawPowRunner.cpp)
+   endif()
 else()
     remove_definitions(/DXMRIG_FEATURE_CUDA)
     remove_definitions(/DXMRIG_FEATURE_NVML)

src/backend/cuda/runners/CudaAstroBWTRunner.cpp

@@ -27,8 +27,6 @@
 #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"
 
 
 constexpr uint32_t xmrig::CudaAstroBWTRunner::BWT_DATA_STRIDE;

src/backend/cuda/runners/CudaKawPowRunner.cpp

@@ -0,0 +1,78 @@
+/* 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-2020 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2020 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 "backend/cuda/runners/CudaKawPowRunner.h"
+#include "backend/cuda/CudaLaunchData.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 "crypto/kawpow/KPCache.h"
+#include "crypto/kawpow/KPHash.h"
+
+#include "3rdparty/libethash/data_sizes.h"
+
+
+xmrig::CudaKawPowRunner::CudaKawPowRunner(size_t index, const CudaLaunchData &data) :
+    CudaBaseRunner(index, data)
+{
+}
+
+
+bool xmrig::CudaKawPowRunner::run(uint32_t /*startNonce*/, uint32_t *rescount, uint32_t *resnonce)
+{
+    return callWrapper(CudaLib::KawPowHash(m_ctx, m_jobBlob, m_target, rescount, resnonce));
+}
+
+
+bool xmrig::CudaKawPowRunner::set(const Job &job, uint8_t *blob)
+{
+    if (!CudaBaseRunner::set(job, blob)) {
+        return false;
+    }
+
+    m_jobBlob = blob;
+
+    const uint64_t height = job.height();
+    const uint32_t epoch = height / KPHash::EPOCH_LENGTH;
+
+    KPCache& cache = KPCache::s_cache;
+    {
+        std::lock_guard<std::mutex> lock(KPCache::s_cacheMutex);
+        cache.init(epoch);
+    }
+
+    const uint64_t start_ms = Chrono::steadyMSecs();
+
+    const bool result = CudaLib::KawPowPrepare(m_ctx, cache.data(), cache.size(), cache.dag_size(epoch), height, dag_sizes);
+
+    const int64_t dt = Chrono::steadyMSecs() - start_ms;
+    if (dt > 500) {
+        LOG_INFO("KawPow DAG for epoch %u calculated (%" PRIu64 " ms)", epoch, dt);
+    }
+
+    return result;
+}

src/backend/cuda/runners/CudaKawPowRunner.h

@@ -0,0 +1,52 @@
+/* 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-2020 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2020 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_CUDAKAWPOWRUNNER_H
+#define XMRIG_CUDAKAWPOWRUNNER_H
+
+
+#include "backend/cuda/runners/CudaBaseRunner.h"
+
+
+namespace xmrig {
+
+
+class CudaKawPowRunner : public CudaBaseRunner
+{
+public:
+    CudaKawPowRunner(size_t index, const CudaLaunchData &data);
+
+protected:
+    bool run(uint32_t startNonce, uint32_t *rescount, uint32_t *resnonce) override;
+    bool set(const Job &job, uint8_t *blob) override;
+
+private:
+    uint8_t* m_jobBlob;
+};
+
+
+} /* namespace xmrig */
+
+
+#endif // XMRIG_CUDAKAWPOWRUNNER_H

src/backend/cuda/wrappers/CudaLib.cpp

@@ -29,6 +29,7 @@
 
 #include "backend/cuda/wrappers/CudaLib.h"
 #include "base/io/Env.h"
+#include "base/io/log/Log.h"
 #include "crypto/rx/RxAlgo.h"
 
 
@@ -64,9 +65,10 @@ static const char *kPluginVersion                       = "pluginVersion";
 static const char *kRelease                             = "release";
 static const char *kRxHash                              = "rxHash";
 static const char *kRxPrepare                           = "rxPrepare";
+static const char *kKawPowHash                          = "KawPowHash";
+static const char *kKawPowPrepare                       = "KawPowPrepare";
 static const char *kSetJob                              = "setJob";
 static const char *kSetJob_v2                           = "setJob_v2";
-static const char *kSymbolNotFound                      = "symbol not found";
 static const char *kVersion                             = "version";
 
 
@@ -88,6 +90,8 @@ 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 KawPowHash_t                                      = bool (*)(nvid_ctx *, uint8_t*, uint64_t, uint32_t *, uint32_t *);
+using KawPowPrepare_t                                   = bool (*)(nvid_ctx *, const void *, size_t, size_t, uint32_t, const uint64_t*);
 using setJob_t                                          = bool (*)(nvid_ctx *, const void *, size_t, int32_t);
 using setJob_v2_t                                       = bool (*)(nvid_ctx *, const void *, size_t, const char *);
 using version_t                                         = uint32_t (*)(Version);
@@ -111,12 +115,14 @@ static pluginVersion_t pPluginVersion                   = nullptr;
 static release_t pRelease                               = nullptr;
 static rxHash_t pRxHash                                 = nullptr;
 static rxPrepare_t pRxPrepare                           = nullptr;
+static KawPowHash_t pKawPowHash                         = nullptr;
+static KawPowPrepare_t pKawPowPrepare                   = nullptr;
 static setJob_t pSetJob                                 = nullptr;
 static setJob_v2_t pSetJob_v2                           = nullptr;
 static version_t pVersion                               = nullptr;
 
 
-#define DLSYM(x) if (uv_dlsym(&cudaLib, k##x, reinterpret_cast<void**>(&p##x)) == -1) { throw std::runtime_error(kSymbolNotFound); }
+#define DLSYM(x) if (uv_dlsym(&cudaLib, k##x, reinterpret_cast<void**>(&p##x)) == -1) { throw std::runtime_error("symbol not found (" #x ")"); }
 
 
 bool CudaLib::m_initialized = false;
@@ -199,6 +205,18 @@ bool xmrig::CudaLib::rxPrepare(nvid_ctx *ctx, const void *dataset, size_t datase
 }
 
 
+bool xmrig::CudaLib::KawPowHash(nvid_ctx *ctx, uint8_t* job_blob, uint64_t target, uint32_t *rescount, uint32_t *resnonce) noexcept
+{
+    return pKawPowHash(ctx, job_blob, target, rescount, resnonce);
+}
+
+
+bool xmrig::CudaLib::KawPowPrepare(nvid_ctx *ctx, const void* cache, size_t cache_size, size_t dag_size, uint32_t height, const uint64_t* dag_sizes) noexcept
+{
+    return pKawPowPrepare(ctx, cache, cache_size, dag_size, height, dag_sizes);
+}
+
+
 bool xmrig::CudaLib::setJob(nvid_ctx *ctx, const void *data, size_t size, const Algorithm &algorithm) noexcept
 {
     const Algorithm algo = RxAlgo::id(algorithm);
@@ -323,7 +341,7 @@ bool xmrig::CudaLib::load()
         return false;
     }
 
-    if (pVersion(ApiVersion) != 3u) {
+    if (pVersion(ApiVersion) != 6u) {
         return false;
     }
 
@@ -347,6 +365,8 @@ bool xmrig::CudaLib::load()
         DLSYM(RxPrepare);
         DLSYM(AstroBWTHash);
         DLSYM(AstroBWTPrepare);
+        DLSYM(KawPowHash);
+        DLSYM(KawPowPrepare);
         DLSYM(Version);
 
         if (!pDeviceInfo_v2) {
@@ -357,6 +377,7 @@ bool xmrig::CudaLib::load()
             DLSYM(SetJob);
         }
     } catch (std::exception &ex) {
+        LOG_ERR("Error loading CUDA library: %s", ex.what());
         return false;
     }
 

src/backend/cuda/wrappers/CudaLib.h

@@ -80,6 +80,8 @@ 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 KawPowHash(nvid_ctx *ctx, uint8_t* job_blob, uint64_t target, uint32_t *rescount, uint32_t *resnonce) noexcept;
+    static bool KawPowPrepare(nvid_ctx *ctx, const void* cache, size_t cache_size, size_t dag_size, uint32_t height, const uint64_t* dag_sizes) 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;