Merge xmrig v6.6.1 into master

src/backend/common/benchmark/BenchState.cpp

@@ -33,17 +33,26 @@
 namespace xmrig {
 
 
-static bool done                        = false;
-static std::mutex mutex;
-static std::shared_ptr<Async> async;
-static uint32_t remaining               = 0;
-static uint64_t doneTime                = 0;
-static uint64_t result                  = 0;
-static uint64_t topDiff                 = 0;
+class BenchStatePrivate
+{
+public:
+    BenchStatePrivate(IBenchListener *listener, uint32_t size) :
+        listener(listener),
+        size(size)
+    {}
 
 
-IBenchListener *BenchState::m_listener  = nullptr;
-uint32_t BenchState::m_size             = 0;
+    IBenchListener *listener;
+    std::mutex mutex;
+    std::shared_ptr<Async> async;
+    uint32_t remaining               = 0;
+    uint32_t size;
+    uint64_t doneTime                = 0;
+};
+
+
+static BenchStatePrivate *d_ptr = nullptr;
+std::atomic<uint64_t> BenchState::m_data{};
 
 
 } // namespace xmrig
@@ -52,7 +61,13 @@ uint32_t BenchState::m_size             = 0;
 
 bool xmrig::BenchState::isDone()
 {
-    return xmrig::done;
+    return d_ptr == nullptr;
+}
+
+
+uint32_t xmrig::BenchState::size()
+{
+    return d_ptr ? d_ptr->size : 0U;
 }
 
 
@@ -71,18 +86,18 @@ uint64_t xmrig::BenchState::referenceHash(const Algorithm &algo, uint32_t size,
 
 uint64_t xmrig::BenchState::start(size_t threads, const IBackend *backend)
 {
-    assert(m_listener != nullptr);
+    assert(d_ptr != nullptr);
 
-    remaining = static_cast<uint32_t>(threads);
+    d_ptr->remaining = static_cast<uint32_t>(threads);
 
-    async = std::make_shared<Async>([] {
-        m_listener->onBenchDone(result, topDiff, doneTime);
-        async.reset();
-        xmrig::done = true;
+    d_ptr->async = std::make_shared<Async>([] {
+        d_ptr->listener->onBenchDone(m_data, 0, d_ptr->doneTime);
+
+        destroy();
     });
 
     const uint64_t ts = Chrono::steadyMSecs();
-    m_listener->onBenchReady(ts, remaining, backend);
+    d_ptr->listener->onBenchReady(ts, d_ptr->remaining, backend);
 
     return ts;
 }
@@ -90,23 +105,39 @@ uint64_t xmrig::BenchState::start(size_t threads, const IBackend *backend)
 
 void xmrig::BenchState::destroy()
 {
-    xmrig::done = true;
-    async.reset();
+    delete d_ptr;
+    d_ptr = nullptr;
 }
 
 
-void xmrig::BenchState::done(uint64_t data, uint64_t diff, uint64_t ts)
+void xmrig::BenchState::done()
 {
-    assert(async && remaining > 0);
+    assert(d_ptr != nullptr && d_ptr->async && d_ptr->remaining > 0);
 
-    std::lock_guard<std::mutex> lock(mutex);
+    const uint64_t ts = Chrono::steadyMSecs();
 
-    result ^= data;
-    doneTime = std::max(doneTime, ts);
-    topDiff  = std::max(topDiff, diff);
-    --remaining;
+    std::lock_guard<std::mutex> lock(d_ptr->mutex);
 
-    if (remaining == 0) {
-        async->send();
+    d_ptr->doneTime = std::max(d_ptr->doneTime, ts);
+    --d_ptr->remaining;
+
+    if (d_ptr->remaining == 0) {
+        d_ptr->async->send();
     }
 }
+
+
+void xmrig::BenchState::init(IBenchListener *listener, uint32_t size)
+{
+    assert(d_ptr == nullptr);
+
+    d_ptr = new BenchStatePrivate(listener, size);
+}
+
+
+void xmrig::BenchState::setSize(uint32_t size)
+{
+    assert(d_ptr != nullptr);
+
+    d_ptr->size = size;
+}

src/backend/common/benchmark/BenchState.h

@@ -20,6 +20,7 @@
 #define XMRIG_BENCHSTATE_H
 
 
+#include <atomic>
 #include <cstddef>
 #include <cstdint>
 
@@ -36,18 +37,19 @@ class BenchState
 {
 public:
     static bool isDone();
+    static uint32_t size();
     static uint64_t referenceHash(const Algorithm &algo, uint32_t size, uint32_t threads);
     static uint64_t start(size_t threads, const IBackend *backend);
     static void destroy();
-    static void done(uint64_t data, uint64_t diff, uint64_t ts);
+    static void done();
+    static void init(IBenchListener *listener, uint32_t size);
+    static void setSize(uint32_t size);
 
-    inline static uint32_t size()                               { return m_size; }
-    inline static void setListener(IBenchListener *listener)    { m_listener = listener; }
-    inline static void setSize(uint32_t size)                   { m_size = size; }
+    inline static uint64_t data()           { return m_data; }
+    inline static void add(uint64_t value)  { m_data.fetch_xor(value, std::memory_order_relaxed); }
 
 private:
-    static IBenchListener *m_listener;
-    static uint32_t m_size;
+    static std::atomic<uint64_t> m_data;
 };
 
 

src/backend/common/benchmark/Benchmark.cpp

@@ -57,5 +57,5 @@ void xmrig::Benchmark::printProgress() const
     const double dt      = static_cast<double>(Chrono::steadyMSecs() - m_startTime) / 1000.0;
     const double percent = static_cast<double>(m_current) / BenchState::size() * 100.0;
 
-    LOG_NOTICE("%s " MAGENTA_BOLD("%5.2f%% ") CYAN_BOLD("%" PRIu64) CYAN("/%" PRIu64) BLACK_BOLD(" (%.3fs)"), Tags::bench(), percent, m_current, BenchState::size(), dt);
+    LOG_NOTICE("%s " MAGENTA_BOLD("%5.2f%% ") CYAN_BOLD("%" PRIu64) CYAN("/%u") BLACK_BOLD(" (%.3fs)"), Tags::bench(), percent, m_current, BenchState::size(), dt);
 }