flex algo low diff share fix

Fix unused warning with C++17 [[maybe_unused]] decoration

CMakeLists.txt

@@ -132,6 +132,7 @@ set(SOURCES_CRYPTO
     src/crypto/common/Nonce.cpp
     src/crypto/common/VirtualMemory.cpp
     src/crypto/flex/flex.cpp
+    src/crypto/flex/flex_keccak.c
    )
 
 if (WITH_MO_BENCHMARK)

src/backend/cpu/CpuBackend.cpp

@@ -36,7 +36,6 @@
 #include "crypto/common/VirtualMemory.h"
 #include "crypto/rx/Rx.h"
 #include "crypto/rx/RxDataset.h"
-#include "crypto/ghostrider/sph_keccak.h"
 
 
 #ifdef XMRIG_FEATURE_API
@@ -360,8 +359,6 @@ void xmrig::CpuBackend::setJob(const Job &job)
     d_ptr->algo         = job.algorithm();
     d_ptr->profileName  = cpu.threads().profileName(job.algorithm());
 
-    hard_coded_eb = (d_ptr->algo.id() != Algorithm::FLEX_KCN) ? 1 : 6;
-
     if (d_ptr->profileName.isNull() || threads.empty()) {
         LOG_WARN("%s " RED_BOLD("disabled") YELLOW(" (no suitable configuration found)"), Tags::cpu());
 

src/backend/cpu/platform/BasicCpuInfo.cpp

@@ -387,8 +387,10 @@ xmrig::CpuThreads xmrig::BasicCpuInfo::threads(const Algorithm &algorithm, uint3
 
 #   ifdef XMRIG_ALGO_GHOSTRIDER
     switch (algorithm.id()) {
-        case Algorithm::GHOSTRIDER_RTM: return CpuThreads(std::max<size_t>(count / 2, 1), 8);
-        case Algorithm::FLEX_KCN:       return CpuThreads(std::max<size_t>(count / 2, 1), 1);
+        case Algorithm::GHOSTRIDER_RTM: return CpuThreads(std::max<size_t>(count_limit2, 1), 8);
+        case Algorithm::FLEX_KCN:       return CpuThreads(std::max<size_t>(count_limit2, 1), 1);
+        default:
+            break;
     }
 #   endif
 

src/core/MoBenchmark.h

@@ -55,8 +55,8 @@ class MoBenchmark : public IJobResultListener {
             // below here use prefetch-disabled MSR setup, keep them grouped
             // so MSR setting doesn't have to flip back and forth
 #           ifdef XMRIG_ALGO_GHOSTRIDER
-            Algorithm::FLEX_KCN,
             Algorithm::GHOSTRIDER_RTM,
+            Algorithm::FLEX_KCN,
 #           endif
 #           ifdef XMRIG_ALGO_CN_HEAVY
             Algorithm::CN_HEAVY_XHV,

src/crypto/cn/CryptoNight_x86.h

@@ -77,7 +77,7 @@ static inline void do_skein_hash(const uint8_t *input, size_t len, uint8_t *outp
 }
 
 static inline void do_flex_skein_hash(const uint8_t* input, size_t len, uint8_t* output) {
-    int r = skein_hash(512, input, 8 * len, (uint8_t*)output);
+    [[maybe_unused]] int r = skein_hash(512, input, 8 * len, (uint8_t*)output);
     assert(SKEIN_SUCCESS == r);
 }
 

src/crypto/flex/flex.cpp

@@ -12,7 +12,6 @@ extern "C" {
 #include "../ghostrider/sph_bmw.h"
 #include "../ghostrider/sph_groestl.h"
 #include "../ghostrider/sph_jh.h"
-#include "../ghostrider/sph_keccak.h"
 #include "../ghostrider/sph_skein.h"
 #include "../ghostrider/sph_luffa.h"
 #include "../ghostrider/sph_cubehash.h"
@@ -24,6 +23,7 @@ extern "C" {
 #include "../ghostrider/sph_shabal.h"
 #include "../ghostrider/sph_whirlpool.h"
 #include "../ghostrider/sph_sha2.h"
+#include "./flex_keccak.h"
 }
 #include <stdio.h>
 
@@ -137,9 +137,9 @@ void flex_hash(const char* input, char* output, cryptonight_ctx** ctx) {
 	sph_whirlpool_context ctx_whirlpool;
 	void *in = (void*) input;
 	int size = 80;
-	sph_keccak512_init(&ctx_keccak);
-	sph_keccak512(&ctx_keccak, in, size);
-	sph_keccak512_close(&ctx_keccak, hash);
+	flex_keccak512_init(&ctx_keccak);
+	flex_keccak512(&ctx_keccak, in, size);
+	flex_keccak512_close(&ctx_keccak, hash);
 	uint8_t selectedAlgoOutput[15] = {0};
 	uint8_t selectedCNAlgoOutput[14] = {0};
 	getAlgoString(&hash, 64, selectedAlgoOutput, 14);
@@ -234,9 +234,9 @@ void flex_hash(const char* input, char* output, cryptonight_ctx** ctx) {
 				sph_groestl512_close(&ctx_groestl, hash);
 				break;
 		case KECCAK:
-				sph_keccak512_init(&ctx_keccak);
-				sph_keccak512(&ctx_keccak, in, size);
-				sph_keccak512_close(&ctx_keccak, hash);
+				flex_keccak512_init(&ctx_keccak);
+				flex_keccak512(&ctx_keccak, in, size);
+				flex_keccak512_close(&ctx_keccak, hash);
 				break;
 		case SKEIN:
 				sph_skein512_init(&ctx_skein);
@@ -292,8 +292,8 @@ void flex_hash(const char* input, char* output, cryptonight_ctx** ctx) {
 		in = (void*) hash;
 		size = 64;
 	}
-	sph_keccak256_init(&ctx_keccak);
-	sph_keccak256(&ctx_keccak, in, size);
-	sph_keccak256_close(&ctx_keccak, hash);
+	flex_keccak256_init(&ctx_keccak);
+	flex_keccak256(&ctx_keccak, in, size);
+	flex_keccak256_close(&ctx_keccak, hash);
 	memcpy(output, hash, 32);
 }

src/crypto/flex/flex_keccak.h

@@ -0,0 +1,293 @@
+/* $Id: sph_keccak.h 216 2010-06-08 09:46:57Z tp $ */
+/**
+ * Keccak interface. This is the interface for Keccak with the
+ * recommended parameters for SHA-3, with output lengths 224, 256,
+ * 384 and 512 bits.
+ *
+ * ==========================(LICENSE BEGIN)============================
+ *
+ * Copyright (c) 2007-2010  Projet RNRT SAPHIR
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * ===========================(LICENSE END)=============================
+ *
+ * @file     sph_keccak.h
+ * @author   Thomas Pornin <thomas.pornin@cryptolog.com>
+ */
+
+#ifndef SPH_KECCAK_H__
+#define SPH_KECCAK_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../ghostrider/sph_types.h"
+#include <stddef.h>
+
+/**
+ * Output size (in bits) for Keccak-224.
+ */
+#define SPH_SIZE_keccak224 224
+
+/**
+ * Output size (in bits) for Keccak-256.
+ */
+#define SPH_SIZE_keccak256 256
+
+/**
+ * Output size (in bits) for Keccak-384.
+ */
+#define SPH_SIZE_keccak384 384
+
+/**
+ * Output size (in bits) for Keccak-512.
+ */
+#define SPH_SIZE_keccak512 512
+
+/**
+ * This structure is a context for Keccak computations: it contains the
+ * intermediate values and some data from the last entered block. Once a
+ * Keccak computation has been performed, the context can be reused for
+ * another computation.
+ *
+ * The contents of this structure are private. A running Keccak computation
+ * can be cloned by copying the context (e.g. with a simple
+ * <code>memcpy()</code>).
+ */
+typedef struct {
+#ifndef DOXYGEN_IGNORE
+  unsigned char buf[144]; /* first field, for alignment */
+  size_t ptr, lim;
+  union {
+#if SPH_64
+    sph_u64 wide[25];
+#endif
+    sph_u32 narrow[50];
+  } u;
+#endif
+} sph_keccak_context;
+
+/**
+ * Type for a Keccak-224 context (identical to the common context).
+ */
+typedef sph_keccak_context sph_keccak224_context;
+
+/**
+ * Type for a Keccak-256 context (identical to the common context).
+ */
+typedef sph_keccak_context sph_keccak256_context;
+
+/**
+ * Type for a Keccak-384 context (identical to the common context).
+ */
+typedef sph_keccak_context sph_keccak384_context;
+
+/**
+ * Type for a Keccak-512 context (identical to the common context).
+ */
+typedef sph_keccak_context sph_keccak512_context;
+
+/**
+ * Initialize a Keccak-224 context. This process performs no memory allocation.
+ *
+ * @param cc   the Keccak-224 context (pointer to a
+ *             <code>flex_keccak224_context</code>)
+ */
+void flex_keccak224_init(void *cc);
+
+/**
+ * Process some data bytes. It is acceptable that <code>len</code> is zero
+ * (in which case this function does nothing).
+ *
+ * @param cc     the Keccak-224 context
+ * @param data   the input data
+ * @param len    the input data length (in bytes)
+ */
+void flex_keccak224(void *cc, const void *data, size_t len);
+
+/**
+ * Terminate the current Keccak-224 computation and output the result into
+ * the provided buffer. The destination buffer must be wide enough to
+ * accomodate the result (28 bytes). The context is automatically
+ * reinitialized.
+ *
+ * @param cc    the Keccak-224 context
+ * @param dst   the destination buffer
+ */
+void flex_keccak224_close(void *cc, void *dst);
+
+/**
+ * Add a few additional bits (0 to 7) to the current computation, then
+ * terminate it and output the result in the provided buffer, which must
+ * be wide enough to accomodate the result (28 bytes). If bit number i
+ * in <code>ub</code> has value 2^i, then the extra bits are those
+ * numbered 7 downto 8-n (this is the big-endian convention at the byte
+ * level). The context is automatically reinitialized.
+ *
+ * @param cc    the Keccak-224 context
+ * @param ub    the extra bits
+ * @param n     the number of extra bits (0 to 7)
+ * @param dst   the destination buffer
+ */
+void flex_keccak224_addbits_and_close(void *cc, unsigned ub, unsigned n,
+                                      void *dst);
+
+/**
+ * Initialize a Keccak-256 context. This process performs no memory allocation.
+ *
+ * @param cc   the Keccak-256 context (pointer to a
+ *             <code>flex_keccak256_context</code>)
+ */
+void flex_keccak256_init(void *cc);
+
+/**
+ * Process some data bytes. It is acceptable that <code>len</code> is zero
+ * (in which case this function does nothing).
+ *
+ * @param cc     the Keccak-256 context
+ * @param data   the input data
+ * @param len    the input data length (in bytes)
+ */
+void flex_keccak256(void *cc, const void *data, size_t len);
+
+/**
+ * Terminate the current Keccak-256 computation and output the result into
+ * the provided buffer. The destination buffer must be wide enough to
+ * accomodate the result (32 bytes). The context is automatically
+ * reinitialized.
+ *
+ * @param cc    the Keccak-256 context
+ * @param dst   the destination buffer
+ */
+void flex_keccak256_close(void *cc, void *dst);
+
+/**
+ * Add a few additional bits (0 to 7) to the current computation, then
+ * terminate it and output the result in the provided buffer, which must
+ * be wide enough to accomodate the result (32 bytes). If bit number i
+ * in <code>ub</code> has value 2^i, then the extra bits are those
+ * numbered 7 downto 8-n (this is the big-endian convention at the byte
+ * level). The context is automatically reinitialized.
+ *
+ * @param cc    the Keccak-256 context
+ * @param ub    the extra bits
+ * @param n     the number of extra bits (0 to 7)
+ * @param dst   the destination buffer
+ */
+void flex_keccak256_addbits_and_close(void *cc, unsigned ub, unsigned n,
+                                      void *dst);
+
+/**
+ * Initialize a Keccak-384 context. This process performs no memory allocation.
+ *
+ * @param cc   the Keccak-384 context (pointer to a
+ *             <code>flex_keccak384_context</code>)
+ */
+void flex_keccak384_init(void *cc);
+
+/**
+ * Process some data bytes. It is acceptable that <code>len</code> is zero
+ * (in which case this function does nothing).
+ *
+ * @param cc     the Keccak-384 context
+ * @param data   the input data
+ * @param len    the input data length (in bytes)
+ */
+void flex_keccak384(void *cc, const void *data, size_t len);
+
+/**
+ * Terminate the current Keccak-384 computation and output the result into
+ * the provided buffer. The destination buffer must be wide enough to
+ * accomodate the result (48 bytes). The context is automatically
+ * reinitialized.
+ *
+ * @param cc    the Keccak-384 context
+ * @param dst   the destination buffer
+ */
+void flex_keccak384_close(void *cc, void *dst);
+
+/**
+ * Add a few additional bits (0 to 7) to the current computation, then
+ * terminate it and output the result in the provided buffer, which must
+ * be wide enough to accomodate the result (48 bytes). If bit number i
+ * in <code>ub</code> has value 2^i, then the extra bits are those
+ * numbered 7 downto 8-n (this is the big-endian convention at the byte
+ * level). The context is automatically reinitialized.
+ *
+ * @param cc    the Keccak-384 context
+ * @param ub    the extra bits
+ * @param n     the number of extra bits (0 to 7)
+ * @param dst   the destination buffer
+ */
+void flex_keccak384_addbits_and_close(void *cc, unsigned ub, unsigned n,
+                                     void *dst);
+
+/**
+ * Initialize a Keccak-512 context. This process performs no memory allocation.
+ *
+ * @param cc   the Keccak-512 context (pointer to a
+ *             <code>flex_keccak512_context</code>)
+ */
+void flex_keccak512_init(void *cc);
+
+/**
+ * Process some data bytes. It is acceptable that <code>len</code> is zero
+ * (in which case this function does nothing).
+ *
+ * @param cc     the Keccak-512 context
+ * @param data   the input data
+ * @param len    the input data length (in bytes)
+ */
+void flex_keccak512(void *cc, const void *data, size_t len);
+
+/**
+ * Terminate the current Keccak-512 computation and output the result into
+ * the provided buffer. The destination buffer must be wide enough to
+ * accomodate the result (64 bytes). The context is automatically
+ * reinitialized.
+ *
+ * @param cc    the Keccak-512 context
+ * @param dst   the destination buffer
+ */
+void flex_keccak512_close(void *cc, void *dst);
+
+/**
+ * Add a few additional bits (0 to 7) to the current computation, then
+ * terminate it and output the result in the provided buffer, which must
+ * be wide enough to accomodate the result (64 bytes). If bit number i
+ * in <code>ub</code> has value 2^i, then the extra bits are those
+ * numbered 7 downto 8-n (this is the big-endian convention at the byte
+ * level). The context is automatically reinitialized.
+ *
+ * @param cc    the Keccak-512 context
+ * @param ub    the extra bits
+ * @param n     the number of extra bits (0 to 7)
+ * @param dst   the destination buffer
+ */
+void flex_keccak512_addbits_and_close(void *cc, unsigned ub, unsigned n,
+                                      void *dst);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/crypto/ghostrider/sph_keccak.c

@@ -39,7 +39,7 @@ extern "C" {
 #endif
 
 // Taken from keccak-gate.c
-int hard_coded_eb = 1;
+static const int hard_coded_eb = 1;
 
 /*
  * Parameters:

src/crypto/ghostrider/sph_keccak.h

@@ -40,9 +40,6 @@
 extern "C" {
 #endif
 
-// Taken from keccak-gate.h
-extern int hard_coded_eb;
-
 #include "sph_types.h"
 #include <stddef.h>
 

src/version.h

@@ -22,7 +22,7 @@
 #define APP_ID        "xmrig"
 #define APP_NAME      "XMRig"
 #define APP_DESC      "XMRig miner"
-#define APP_VERSION   "6.21.3-mo14"
+#define APP_VERSION   "6.21.3-mo15"
 #define APP_DOMAIN    "xmrig.com"
 #define APP_SITE      "www.xmrig.com"
 #define APP_COPYRIGHT "Copyright (C) 2016-2024 xmrig.com"