Added GpuWorker class.

src/backend/common/GpuWorker.cpp

@@ -0,0 +1,52 @@
+/* XMRig
+ * Copyright (c) 2018-2020 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 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/common/GpuWorker.h"
+#include "base/tools/Chrono.h"
+
+
+xmrig::GpuWorker::GpuWorker(size_t id, int64_t affinity, int priority, uint32_t deviceIndex) : Worker(id, affinity, priority),
+    m_deviceIndex(deviceIndex)
+{
+}
+
+
+void xmrig::GpuWorker::storeStats()
+{
+    // Get index which is unused now
+    const uint32_t index = m_index.load(std::memory_order_relaxed) ^ 1;
+
+    // Fill in the data for that index
+    m_hashCount[index] = m_count;
+    m_timestamp[index] = Chrono::steadyMSecs();
+
+    // Switch to that index
+    // All data will be in memory by the time it completes thanks to std::memory_order_seq_cst
+    m_index.fetch_xor(1, std::memory_order_seq_cst);
+}
+
+
+void xmrig::GpuWorker::hashrateData(uint64_t &hashCount, uint64_t &timeStamp, uint64_t &rawHashes) const
+{
+    const uint32_t index = m_index.load(std::memory_order_relaxed);
+
+    rawHashes = m_hashrateData.interpolate(timeStamp);
+    hashCount = m_hashCount[index];
+    timeStamp = m_timestamp[index];
+}

src/backend/common/GpuWorker.h

@@ -0,0 +1,58 @@
+/* XMRig
+ * Copyright (c) 2018-2020 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 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_GPUWORKER_H
+#define XMRIG_GPUWORKER_H
+
+
+#include <atomic>
+
+
+#include "backend/common/HashrateInterpolator.h"
+#include "backend/common/Worker.h"
+
+
+namespace xmrig {
+
+
+class GpuWorker : public Worker
+{
+public:
+    GpuWorker(size_t id, int64_t affinity, int priority, uint32_t m_deviceIndex);
+
+protected:
+    inline const VirtualMemory *memory() const override     { return nullptr; }
+    inline uint32_t deviceIndex() const                     { return m_deviceIndex; }
+
+    void hashrateData(uint64_t &hashCount, uint64_t &timeStamp, uint64_t &rawHashes) const override;
+
+protected:
+    void storeStats();
+
+    const uint32_t m_deviceIndex;
+    HashrateInterpolator m_hashrateData;
+    std::atomic<uint32_t> m_index   = {};
+    uint64_t m_hashCount[2]         = {};
+    uint64_t m_timestamp[2]         = {};
+};
+
+
+} // namespace xmrig
+
+
+#endif /* XMRIG_GPUWORKER_H */

src/backend/common/HashrateInterpolator.cpp

@@ -1,10 +1,4 @@
 /* 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>
  *

src/backend/common/HashrateInterpolator.h

@@ -1,10 +1,4 @@
 /* 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>
  *
@@ -47,7 +41,7 @@ public:
 private:
     // Buffer of hashrate counters, used for linear interpolation of past data
     mutable std::mutex m_lock;
-    std::deque<std::pair<uint64_t, uint64_t>> m_data;
+    std::deque<std::pair<uint64_t, uint64_t> > m_data;
 };
 
 

src/backend/common/Worker.cpp

@@ -1,13 +1,6 @@
 /* XMRig
- * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright (c) 2018-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright (c) 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
- * 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      Lee Clagett <https://github.com/vtnerd>
- * 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
@@ -26,7 +19,6 @@
 
 #include "backend/common/Worker.h"
 #include "base/kernel/Platform.h"
-#include "base/tools/Chrono.h"
 #include "crypto/common/VirtualMemory.h"
 
 
@@ -39,27 +31,3 @@ xmrig::Worker::Worker(size_t id, int64_t affinity, int priority) :
     Platform::trySetThreadAffinity(affinity);
     Platform::setThreadPriority(priority);
 }
-
-
-void xmrig::Worker::storeStats()
-{
-    // Get index which is unused now
-    const uint32_t index = m_index.load(std::memory_order_relaxed) ^ 1;
-
-    // Fill in the data for that index
-    m_hashCount[index] = m_count;
-    m_timestamp[index] = Chrono::steadyMSecs();
-
-    // Switch to that index
-    // All data will be in memory by the time it completes thanks to std::memory_order_seq_cst
-    m_index.fetch_xor(1, std::memory_order_seq_cst);
-}
-
-
-void xmrig::Worker::getHashrateData(uint64_t& hashCount, uint64_t& timeStamp) const
-{
-    const uint32_t index = m_index.load(std::memory_order_relaxed);
-
-    hashCount = m_hashCount[index];
-    timeStamp = m_timestamp[index];
-}

src/backend/common/Worker.h

@@ -1,13 +1,6 @@
 /* XMRig
- * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright (c) 2018-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright (c) 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
- * 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      Lee Clagett <https://github.com/vtnerd>
- * 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
@@ -27,9 +20,6 @@
 #define XMRIG_WORKER_H
 
 
-#include <atomic>
-
-
 #include "backend/common/interfaces/IWorker.h"
 
 
@@ -41,23 +31,17 @@ class Worker : public IWorker
 public:
     Worker(size_t id, int64_t affinity, int priority);
 
-    inline const VirtualMemory *memory() const override   { return nullptr; }
-    inline size_t id() const override                     { return m_id; }
-    inline uint64_t rawHashes() const override            { return m_count; }
-    inline void jobEarlyNotification(const Job&) override {}
-
-    void getHashrateData(uint64_t& hashCount, uint64_t& timeStamp) const override;
-
 protected:
-    void storeStats();
+    inline int64_t affinity() const                         { return m_affinity; }
+    inline size_t id() const override                       { return m_id; }
+    inline uint32_t node() const                            { return m_node; }
 
+    uint64_t m_count                = 0;
+
+private:
     const int64_t m_affinity;
     const size_t m_id;
-    std::atomic<uint32_t> m_index   = {};
     uint32_t m_node                 = 0;
-    uint64_t m_count                = 0;
-    uint64_t m_hashCount[2]         = {};
-    uint64_t m_timestamp[2]         = {};
 };
 
 

src/backend/common/Workers.cpp

@@ -58,20 +58,6 @@ public:
 };
 
 
-template<class T>
-inline static void getHashrateData(IWorker *worker, uint64_t &hashCount, uint64_t &timeStamp)
-{
-    worker->getHashrateData(hashCount, timeStamp);
-}
-
-
-template<>
-inline void getHashrateData<xmrig::CpuLaunchData>(IWorker *worker, uint64_t &hashCount, uint64_t &)
-{
-    hashCount = worker->rawHashes();
-}
-
-
 } // namespace xmrig
 
 
@@ -100,19 +86,20 @@ bool xmrig::Workers<T>::tick(uint64_t)
     uint64_t ts             = Chrono::steadyMSecs();
     bool totalAvailable     = true;
     uint64_t totalHashCount = 0;
+    uint64_t hashCount      = 0;
+    uint64_t rawHashes      = 0;
 
     for (Thread<T> *handle : m_workers) {
         IWorker *worker = handle->worker();
         if (worker) {
-            uint64_t hashCount;
+            worker->hashrateData(hashCount, ts, rawHashes);
-            getHashrateData<T>(worker, hashCount, ts);
             d_ptr->hashrate->add(handle->id() + 1, hashCount, ts);
 
-            const uint64_t n = worker->rawHashes();
+            if (rawHashes == 0) {
-            if (n == 0) {
                 totalAvailable = false;
             }
-            totalHashCount += n;
+
+            totalHashCount += rawHashes;
         }
     }
 

src/backend/common/common.cmake

@@ -1,6 +1,5 @@
 set(HEADERS_BACKEND_COMMON
     src/backend/common/Hashrate.h
-    src/backend/common/HashrateInterpolator.h
     src/backend/common/Tags.h
     src/backend/common/interfaces/IBackend.h
     src/backend/common/interfaces/IRxListener.h
@@ -16,7 +15,6 @@ set(HEADERS_BACKEND_COMMON
 
 set(SOURCES_BACKEND_COMMON
     src/backend/common/Hashrate.cpp
-    src/backend/common/HashrateInterpolator.cpp
     src/backend/common/Threads.cpp
     src/backend/common/Worker.cpp
     src/backend/common/Workers.cpp
@@ -35,3 +33,16 @@ if (WITH_RANDOMX AND WITH_BENCHMARK)
         src/backend/common/benchmark/BenchState.cpp
         )
 endif()
+
+
+if (WITH_OPENCL OR WITH_CUDA)
+    list(APPEND HEADERS_BACKEND_COMMON
+        src/backend/common/HashrateInterpolator.h
+        src/backend/common/GpuWorker.h
+        )
+
+    list(APPEND SOURCES_BACKEND_COMMON
+        src/backend/common/HashrateInterpolator.cpp
+        src/backend/common/GpuWorker.cpp
+        )
+endif()

src/backend/common/interfaces/IWorker.h

@@ -42,14 +42,13 @@ public:
     IWorker()           = default;
     virtual ~IWorker()  = default;
 
-    virtual bool selfTest()                                                         = 0;
+    virtual bool selfTest()                                                                         = 0;
-    virtual const VirtualMemory *memory() const                                     = 0;
+    virtual const VirtualMemory *memory() const                                                     = 0;
-    virtual size_t id() const                                                       = 0;
+    virtual size_t id() const                                                                       = 0;
-    virtual size_t intensity() const                                                = 0;
+    virtual size_t intensity() const                                                                = 0;
-    virtual uint64_t rawHashes() const                                              = 0;
+    virtual void hashrateData(uint64_t &hashCount, uint64_t &timeStamp, uint64_t &rawHashes) const  = 0;
-    virtual void getHashrateData(uint64_t &hashCount, uint64_t &timeStamp) const    = 0;
+    virtual void jobEarlyNotification(const Job &job)                                               = 0;
-    virtual void jobEarlyNotification(const Job &job)                               = 0;
+    virtual void start()                                                                            = 0;
-    virtual void start()                                                            = 0;
 };
 
 

src/backend/cpu/CpuWorker.cpp

@@ -1,13 +1,6 @@
 /* XMRig
- * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright (c) 2018-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright (c) 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
- * 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      Lee Clagett <https://github.com/vtnerd>
- * 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
@@ -80,7 +73,7 @@ xmrig::CpuWorker<N>::CpuWorker(size_t id, const CpuLaunchData &data) :
     m_threads(data.threads),
     m_ctx()
 {
-    m_memory = new VirtualMemory(m_algorithm.l3() * N, data.hugePages, false, true, m_node);
+    m_memory = new VirtualMemory(m_algorithm.l3() * N, data.hugePages, false, true, node());
 }
 
 
@@ -100,7 +93,7 @@ xmrig::CpuWorker<N>::~CpuWorker()
 template<size_t N>
 void xmrig::CpuWorker<N>::allocateRandomX_VM()
 {
-    RxDataset *dataset = Rx::dataset(m_job.currentJob(), m_node);
+    RxDataset *dataset = Rx::dataset(m_job.currentJob(), node());
 
     while (dataset == nullptr) {
         std::this_thread::sleep_for(std::chrono::milliseconds(200));
@@ -109,13 +102,13 @@ void xmrig::CpuWorker<N>::allocateRandomX_VM()
             return;
         }
 
-        dataset = Rx::dataset(m_job.currentJob(), m_node);
+        dataset = Rx::dataset(m_job.currentJob(), node());
     }
 
     if (!m_vm) {
         // Try to allocate scratchpad from dataset's 1 GB huge pages, if normal huge pages are not available
         uint8_t* scratchpad = m_memory->isHugePages() ? m_memory->scratchpad() : dataset->tryAllocateScrathpad();
-        m_vm = RxVm::create(dataset, scratchpad ? scratchpad : m_memory->scratchpad(), !m_hwAES, m_assembly, m_node);
+        m_vm = RxVm::create(dataset, scratchpad ? scratchpad : m_memory->scratchpad(), !m_hwAES, m_assembly, node());
     }
 }
 #endif
@@ -189,6 +182,14 @@ bool xmrig::CpuWorker<N>::selfTest()
 }
 
 
+template<size_t N>
+void xmrig::CpuWorker<N>::hashrateData(uint64_t &hashCount, uint64_t &, uint64_t &rawHashes) const
+{
+    hashCount = m_count;
+    rawHashes = m_count;
+}
+
+
 template<size_t N>
 void xmrig::CpuWorker<N>::start()
 {

src/backend/cpu/CpuWorker.h

@@ -1,13 +1,6 @@
 /* XMRig
- * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright (c) 2018-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright (c) 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
- * 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      Lee Clagett <https://github.com/vtnerd>
- * 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
@@ -56,10 +49,12 @@ public:
 
 protected:
     bool selfTest() override;
+    void hashrateData(uint64_t &hashCount, uint64_t &timeStamp, uint64_t &rawHashes) const override;
     void start() override;
 
-    inline const VirtualMemory *memory() const override { return m_memory; }
+    inline const VirtualMemory *memory() const override     { return m_memory; }
-    inline size_t intensity() const override            { return N; }
+    inline size_t intensity() const override                { return N; }
+    inline void jobEarlyNotification(const Job&) override   {}
 
 private:
     inline cn_hash_fun fn(const Algorithm &algorithm) const { return CnHash::fn(algorithm, m_av, m_assembly); }

src/backend/cuda/CudaWorker.cpp

@@ -1,13 +1,6 @@
 /* XMRig
- * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright (c) 2018-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright (c) 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
- * 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      Lee Clagett <https://github.com/vtnerd>
- * 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
@@ -61,7 +54,7 @@ static constexpr uint32_t kReserveCount = 32768;
 std::atomic<bool> CudaWorker::ready;
 
 
-static inline bool isReady()                         { return !Nonce::isPaused() && CudaWorker::ready; }
+static inline bool isReady()    { return !Nonce::isPaused() && CudaWorker::ready; }
 
 
 } // namespace xmrig
@@ -69,10 +62,9 @@ static inline bool isReady()                         { return !Nonce::isPaused()
 
 
 xmrig::CudaWorker::CudaWorker(size_t id, const CudaLaunchData &data) :
-    Worker(id, data.thread.affinity(), -1),
+    GpuWorker(id, data.thread.affinity(), -1, data.device.index()),
     m_algorithm(data.algorithm),
-    m_miner(data.miner),
+    m_miner(data.miner)
-    m_deviceIndex(data.device.index())
 {
     switch (m_algorithm.family()) {
     case Algorithm::RANDOM_X:
@@ -119,13 +111,7 @@ xmrig::CudaWorker::~CudaWorker()
 }
 
 
-uint64_t xmrig::CudaWorker::rawHashes() const
+void xmrig::CudaWorker::jobEarlyNotification(const Job &job)
-{
-    return m_hashrateData.interpolate(Chrono::steadyMSecs());
-}
-
-
-void xmrig::CudaWorker::jobEarlyNotification(const Job& job)
 {
     if (m_runner) {
         m_runner->jobEarlyNotification(job);
@@ -213,5 +199,5 @@ void xmrig::CudaWorker::storeStats()
     const uint64_t timeStamp = Chrono::steadyMSecs();
     m_hashrateData.addDataPoint(m_count, timeStamp);
 
-    Worker::storeStats();
+    GpuWorker::storeStats();
 }

src/backend/cuda/CudaWorker.h

@@ -1,13 +1,6 @@
 /* XMRig
- * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright (c) 2018-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright (c) 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
- * 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      Lee Clagett <https://github.com/vtnerd>
- * 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
@@ -27,8 +20,7 @@
 #define XMRIG_CUDAWORKER_H
 
 
-#include "backend/common/HashrateInterpolator.h"
+#include "backend/common/GpuWorker.h"
-#include "backend/common/Worker.h"
 #include "backend/common/WorkerJob.h"
 #include "backend/cuda/CudaLaunchData.h"
 #include "base/tools/Object.h"
@@ -41,7 +33,7 @@ namespace xmrig {
 class ICudaRunner;
 
 
-class CudaWorker : public Worker
+class CudaWorker : public GpuWorker
 {
 public:
     XMRIG_DISABLE_COPY_MOVE_DEFAULT(CudaWorker)
@@ -50,8 +42,7 @@ public:
 
     ~CudaWorker() override;
 
-    uint64_t rawHashes() const override;
+    void jobEarlyNotification(const Job &job) override;
-    void jobEarlyNotification(const Job&) override;
 
     static std::atomic<bool> ready;
 
@@ -68,9 +59,6 @@ private:
     const Miner *m_miner;
     ICudaRunner *m_runner = nullptr;
     WorkerJob<1> m_job;
-    uint32_t m_deviceIndex;
-
-    HashrateInterpolator m_hashrateData;
 };
 
 

src/backend/opencl/OclWorker.cpp

@@ -1,13 +1,6 @@
 /* XMRig
- * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright (c) 2018-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright (c) 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
- * 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      Lee Clagett <https://github.com/vtnerd>
- * 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
@@ -59,7 +52,7 @@ namespace xmrig {
 std::atomic<bool> OclWorker::ready;
 
 
-static inline bool isReady()                         { return !Nonce::isPaused() && OclWorker::ready; }
+static inline bool isReady()    { return !Nonce::isPaused() && OclWorker::ready; }
 
 
 static inline void printError(size_t id, const char *error)
@@ -73,11 +66,10 @@ static inline void printError(size_t id, const char *error)
 
 
 xmrig::OclWorker::OclWorker(size_t id, const OclLaunchData &data) :
-    Worker(id, data.affinity, -1),
+    GpuWorker(id, data.affinity, -1, data.device.index()),
     m_algorithm(data.algorithm),
     m_miner(data.miner),
-    m_sharedData(OclSharedState::get(data.device.index())),
+    m_sharedData(OclSharedState::get(data.device.index()))
-    m_deviceIndex(data.device.index())
 {
     switch (m_algorithm.family()) {
     case Algorithm::RANDOM_X:
@@ -137,13 +129,7 @@ xmrig::OclWorker::~OclWorker()
 }
 
 
-uint64_t xmrig::OclWorker::rawHashes() const
+void xmrig::OclWorker::jobEarlyNotification(const Job &job)
-{
-    return m_hashrateData.interpolate(Chrono::steadyMSecs());
-}
-
-
-void xmrig::OclWorker::jobEarlyNotification(const Job& job)
 {
     if (m_runner) {
         m_runner->jobEarlyNotification(job);
@@ -180,7 +166,7 @@ void xmrig::OclWorker::start()
                 break;
             }
 
-            m_sharedData.resumeDelay(m_id);
+            m_sharedData.resumeDelay(id());
 
             if (!consumeJob()) {
                 return;
@@ -188,7 +174,7 @@ void xmrig::OclWorker::start()
         }
 
         while (!Nonce::isOutdated(Nonce::OPENCL, m_job.sequence())) {
-            m_sharedData.adjustDelay(m_id);
+            m_sharedData.adjustDelay(id());
 
             const uint64_t t = Chrono::steadyMSecs();
 
@@ -254,5 +240,5 @@ void xmrig::OclWorker::storeStats(uint64_t t)
 
     m_sharedData.setRunTime(timeStamp - t);
 
-    Worker::storeStats();
+    GpuWorker::storeStats();
 }

src/backend/opencl/OclWorker.h

@@ -1,13 +1,6 @@
 /* XMRig
- * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright (c) 2018-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright (c) 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
- * 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      Lee Clagett <https://github.com/vtnerd>
- * 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
@@ -27,8 +20,7 @@
 #define XMRIG_OCLWORKER_H
 
 
-#include "backend/common/HashrateInterpolator.h"
+#include "backend/common/GpuWorker.h"
-#include "backend/common/Worker.h"
 #include "backend/common/WorkerJob.h"
 #include "backend/opencl/OclLaunchData.h"
 #include "base/tools/Object.h"
@@ -42,7 +34,7 @@ class IOclRunner;
 class Job;
 
 
-class OclWorker : public Worker
+class OclWorker : public GpuWorker
 {
 public:
     XMRIG_DISABLE_COPY_MOVE_DEFAULT(OclWorker)
@@ -51,8 +43,7 @@ public:
 
     ~OclWorker() override;
 
-    uint64_t rawHashes() const override;
+    void jobEarlyNotification(const Job &job) override;
-    void jobEarlyNotification(const Job&) override;
 
     static std::atomic<bool> ready;
 
@@ -70,9 +61,6 @@ private:
     IOclRunner *m_runner = nullptr;
     OclSharedData &m_sharedData;
     WorkerJob<1> m_job;
-    uint32_t m_deviceIndex;
-
-    HashrateInterpolator m_hashrateData;
 };