Add DoubleWorker class.

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; }