Add DoubleWorker class.

CMakeLists.txt

@@ -21,6 +21,7 @@ set(HEADERS
     src/Options.h
     src/Summary.h
     src/version.h
+    src/workers/DoubleWorker.h
     src/workers/Handle.h
     src/workers/SingleWorker.h
     src/workers/Telemetry.h
@@ -52,6 +53,7 @@ set(SOURCES
     src/net/Url.cpp
     src/Options.cpp
     src/Summary.cpp
+    src/workers/DoubleWorker.cpp
     src/workers/Handle.cpp
     src/workers/SingleWorker.cpp
     src/workers/Telemetry.cpp
@@ -113,7 +115,7 @@ if (CMAKE_CXX_COMPILER_ID MATCHES GNU)
 
     add_definitions(/D_GNU_SOURCE)
 
-    #set(CMAKE_C_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -gdwarf-2")
+    set(CMAKE_C_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -gdwarf-2")
 
 elseif (CMAKE_CXX_COMPILER_ID MATCHES MSVC)
 

src/App.cpp

@@ -82,7 +82,7 @@ int App::exec()
     Mem::allocate(m_options->algo(), m_options->threads(), m_options->doubleHash());
     Summary::print();
 
-    Workers::start(m_options->threads(), m_options->affinity(), m_options->nicehash());
+    Workers::start(m_options->affinity(), m_options->nicehash());
 
     m_network->connect();
 

src/Mem.h

@@ -48,9 +48,11 @@ public:
     static void *calloc(size_t num, size_t size);
     static void release();
 
+    static inline bool isDoubleHash()         { return m_doubleHash; }
     static inline bool isHugepagesAvailable() { return m_flags & HugepagesAvailable; }
     static inline bool isHugepagesEnabled()   { return m_flags & HugepagesEnabled; }
     static inline int flags()                 { return m_flags; }
+    static inline int threads()               { return m_threads; }
 
 private:
     static bool m_doubleHash;

src/crypto/CryptoNight.cpp

@@ -38,38 +38,38 @@ static void cryptonight_av1_aesni(const void *input, size_t size, void *output,
 }
 
 
-static void cryptonight_av2_aesni_double(const void *input, size_t size, void *output, struct cryptonight_ctx *ctx) {
+static void cryptonight_av2_aesni_double(const void *input, size_t size, void *output, cryptonight_ctx *ctx) {
     cryptonight_double_hash<0x80000, MEMORY, 0x1FFFF0, false>(input, size, output, ctx);
 }
 
 
-static void cryptonight_av3_softaes(const void *input, size_t size, void *output, struct cryptonight_ctx *ctx) {
+static void cryptonight_av3_softaes(const void *input, size_t size, void *output, cryptonight_ctx *ctx) {
     cryptonight_hash<0x80000, MEMORY, 0x1FFFF0, true>(input, size, output, ctx);
 }
 
 
-static void cryptonight_av4_softaes_double(const void *input, size_t size, void *output, struct cryptonight_ctx *ctx) {
+static void cryptonight_av4_softaes_double(const void *input, size_t size, void *output, cryptonight_ctx *ctx) {
     cryptonight_double_hash<0x80000, MEMORY, 0x1FFFF0, true>(input, size, output, ctx);
 }
 
 
 #ifndef XMRIG_NO_AEON
-static void cryptonight_lite_av1_aesni(const void *input, size_t size, void *output, struct cryptonight_ctx *ctx) {
+static void cryptonight_lite_av1_aesni(const void *input, size_t size, void *output, cryptonight_ctx *ctx) {
     cryptonight_hash<0x40000, MEMORY_LITE, 0xFFFF0, false>(input, size, output, ctx);
 }
 
 
-static void cryptonight_lite_av2_aesni_double(const void *input, size_t size, void *output, struct cryptonight_ctx *ctx) {
+static void cryptonight_lite_av2_aesni_double(const void *input, size_t size, void *output, cryptonight_ctx *ctx) {
     cryptonight_double_hash<0x40000, MEMORY_LITE, 0xFFFF0, false>(input, size, output, ctx);
 }
 
 
-static void cryptonight_lite_av3_softaes(const void *input, size_t size, void *output, struct cryptonight_ctx *ctx) {
+static void cryptonight_lite_av3_softaes(const void *input, size_t size, void *output, cryptonight_ctx *ctx) {
     cryptonight_hash<0x40000, MEMORY_LITE, 0xFFFF0, true>(input, size, output, ctx);
 }
 
 
-static void cryptonight_lite_av4_softaes_double(const void *input, size_t size, void *output, struct cryptonight_ctx *ctx) {
+static void cryptonight_lite_av4_softaes_double(const void *input, size_t size, void *output, cryptonight_ctx *ctx) {
     cryptonight_double_hash<0x40000, MEMORY_LITE, 0xFFFF0, true>(input, size, output, ctx);
 }
 
@@ -119,6 +119,12 @@ bool CryptoNight::init(int algo, int variant)
 }
 
 
+void CryptoNight::hash(const uint8_t *input, size_t size, uint8_t *output, cryptonight_ctx *ctx)
+{
+    cryptonight_hash_ctx(input, size, output, ctx);
+}
+
+
 bool CryptoNight::selfTest(int algo) {
     if (cryptonight_hash_ctx == nullptr) {
         return false;

src/crypto/CryptoNight.h

@@ -51,6 +51,7 @@ class CryptoNight
 public:
     static bool hash(const Job &job, JobResult &result, cryptonight_ctx *ctx);
     static bool init(int algo, int variant);
+    static void hash(const uint8_t *input, size_t size, uint8_t *output, cryptonight_ctx *ctx);
 
 private:
     static bool selfTest(int algo);

src/net/Job.h

@@ -50,8 +50,9 @@ public:
     inline void setPoolId(int poolId)  { m_poolId = poolId; }
 
     static bool fromHex(const char* in, unsigned int len, unsigned char* out);
-    static void toHex(const unsigned char* in, unsigned int len, char* out);
+    static inline uint32_t *nonce(uint8_t *blob)   { return reinterpret_cast<uint32_t*>(blob + 39); }
     static inline uint64_t toDiff(uint64_t target) { return 0xFFFFFFFFFFFFFFFFULL / target; }
+    static void toHex(const unsigned char* in, unsigned int len, char* out);
 
 private:
     int m_poolId;

src/net/JobResult.h

@@ -31,6 +31,13 @@
 class JobResult
 {
 public:
+    inline JobResult() : poolId(0), nonce(0) {}
+    inline JobResult(int poolId, const char *jobId, uint32_t nonce, const uint8_t *result) : poolId(poolId), nonce(nonce)
+    {
+        memcpy(this->jobId, jobId, sizeof(this->jobId));
+        memcpy(this->result, result, sizeof(this->result));
+    }
+
     char jobId[64];
     int poolId;
     uint32_t nonce;

src/workers/DoubleWorker.cpp

@@ -0,0 +1,97 @@
+/* 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 2016-2017 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 <thread>
+
+
+#include "crypto/CryptoNight.h"
+#include "workers/DoubleWorker.h"
+#include "workers/Workers.h"
+
+
+DoubleWorker::DoubleWorker(Handle *handle)
+    : Worker(handle),
+    m_nonce1(0),
+    m_nonce2(0)
+{
+}
+
+
+void DoubleWorker::start()
+{
+    while (true) {
+        if (Workers::isPaused()) {
+            do {
+                std::this_thread::sleep_for(std::chrono::milliseconds(200));
+            }
+            while (Workers::isPaused());
+
+            consumeJob();
+        }
+
+        while (!Workers::isOutdated(m_sequence)) {
+            if ((m_count & 0xF) == 0) {
+                storeStats();
+            }
+
+            m_count += 2;
+            *Job::nonce(m_blob)                = ++m_nonce1;
+            *Job::nonce(m_blob + m_job.size()) = ++m_nonce2;
+
+            CryptoNight::hash(m_blob, m_job.size(), m_hash, m_ctx);
+
+            if (*reinterpret_cast<uint64_t*>(m_hash + 24) < m_job.target()) {
+                Workers::submit(JobResult(m_job.poolId(), m_job.id(), m_nonce1, m_hash));
+            }
+
+            if (*reinterpret_cast<uint64_t*>(m_hash + 32 + 24) < m_job.target()) {
+                Workers::submit(JobResult(m_job.poolId(), m_job.id(), m_nonce2, m_hash + 32));
+            }
+
+            std::this_thread::yield();
+        }
+
+        consumeJob();
+    }
+}
+
+
+
+void DoubleWorker::consumeJob()
+{
+    m_job = Workers::job();
+    m_sequence = Workers::sequence();
+
+    memcpy(m_blob,                m_job.blob(), m_job.size());
+    memcpy(m_blob + m_job.size(), m_job.blob(), m_job.size());
+
+    if (m_nicehash) {
+        m_nonce1 = (*Job::nonce(m_blob)                & 0xff000000U) + (0xffffffU / (m_threads * 2) * m_id);
+        m_nonce2 = (*Job::nonce(m_blob + m_job.size()) & 0xff000000U) + (0xffffffU / (m_threads * 2) * (m_id + m_threads));
+    }
+    else {
+        m_nonce1 = 0xffffffffU / (m_threads * 2) * m_id;
+        m_nonce2 = 0xffffffffU / (m_threads * 2) * (m_id + m_threads);
+    }
+}

src/workers/DoubleWorker.h

@@ -0,0 +1,55 @@
+/* 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 2016-2017 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 __DOUBLEWORKER_H__
+#define __DOUBLEWORKER_H__
+
+
+#include "align.h"
+#include "net/Job.h"
+#include "net/JobResult.h"
+#include "workers/Worker.h"
+
+
+class Handle;
+
+
+class DoubleWorker : public Worker
+{
+public:
+    DoubleWorker(Handle *handle);
+
+    void start() override;
+
+private:
+    void consumeJob();
+
+    Job m_job;
+    uint32_t m_nonce1;
+    uint32_t m_nonce2;
+    uint8_t m_hash[64];
+    uint8_t	m_blob[84 * 2];
+};
+
+
+#endif /* __SINGLEWORKER_H__ */

src/workers/SingleWorker.cpp

@@ -60,7 +60,7 @@ void SingleWorker::start()
                 Workers::submit(m_result);
             }
 
-//            sched_yield();
+            std::this_thread::yield();
         }
 
         consumeJob();

src/workers/Worker.cpp

@@ -40,8 +40,6 @@ Worker::Worker(Handle *handle) :
     m_count(0),
     m_sequence(0)
 {
-    handle->setWorker(this);
-
     if (Cpu::threads() > 1 && handle->affinity() != -1L) {
         Cpu::setAffinity(m_id, handle->affinity());
     }

src/workers/Workers.cpp

@@ -26,6 +26,8 @@
 
 #include "Console.h"
 #include "interfaces/IJobResultListener.h"
+#include "Mem.h"
+#include "workers/DoubleWorker.h"
 #include "workers/Handle.h"
 #include "workers/SingleWorker.h"
 #include "workers/Telemetry.h"
@@ -67,8 +69,9 @@ void Workers::setJob(const Job &job)
 }
 
 
-void Workers::start(int threads, int64_t affinity, bool nicehash)
+void Workers::start(int64_t affinity, bool nicehash)
 {
+    const int threads = Mem::threads();
     m_telemetry = new Telemetry(threads);
 
     uv_mutex_init(&m_mutex);
@@ -103,8 +106,14 @@ void Workers::submit(const JobResult &result)
 void Workers::onReady(void *arg)
 {
     auto handle = static_cast<Handle*>(arg);
-    IWorker *worker = new SingleWorker(handle);
-    worker->start();
+    if (Mem::isDoubleHash()) {
+        handle->setWorker(new DoubleWorker(handle));
+    }
+    else {
+        handle->setWorker(new SingleWorker(handle));
+    }
+
+    handle->worker()->start();
 }
 
 

src/workers/Workers.h

@@ -44,7 +44,7 @@ class Workers
 public:
     static Job job();
     static void setJob(const Job &job);
-    static void start(int threads, int64_t affinity, bool nicehash);
+    static void start(int64_t affinity, bool nicehash);
     static void submit(const JobResult &result);
 
     static inline bool isOutdated(uint64_t sequence)             { return m_sequence.load(std::memory_order_relaxed) != sequence; }