Merge 862280f28c into cd2fd9d7a6

src/backend/common/misc/PciTopology.h

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2018-2024 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2016-2024 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
@@ -19,10 +19,8 @@
 #ifndef XMRIG_PCITOPOLOGY_H
 #define XMRIG_PCITOPOLOGY_H
 
-
 #include <cstdio>
 
-
 #include "base/tools/String.h"
 
 
@@ -33,7 +31,14 @@ class PciTopology
 {
 public:
     PciTopology() = default;
-    PciTopology(uint32_t bus, uint32_t device, uint32_t function) : m_valid(true), m_bus(bus), m_device(device), m_function(function) {}
+
+    template<typename T>
+    inline PciTopology(T bus, T device, T function)
+        : m_valid(true),
+          m_bus(static_cast<uint8_t>(bus)),
+          m_device(static_cast<uint8_t>(device)),
+          m_function(static_cast<uint8_t>(function))
+    {}
 
     inline bool isEqual(const PciTopology &other) const     { return m_valid == other.m_valid && toUint32() == other.toUint32(); }
     inline bool isValid() const                             { return m_valid; }
@@ -70,4 +75,4 @@ private:
 } // namespace xmrig
 
 
-#endif /* XMRIG_PCITOPOLOGY_H */
+#endif // XMRIG_PCITOPOLOGY_H

src/backend/cuda/CudaBackend.cpp

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2018-2024 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2016-2024 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
@@ -227,7 +227,7 @@ public:
 #           endif
 
             Log::print("|" CYAN_BOLD("%3zu") " |" CYAN_BOLD("%4u") " |" YELLOW(" %7s") " |" CYAN_BOLD("%10d") " |" CYAN_BOLD("%8d") " |"
-                       CYAN_BOLD("%7d") " |" CYAN_BOLD("%3d") " |" CYAN_BOLD("%4d") " |" CYAN("%7zu") " | " GREEN("%s"),
+                       CYAN_BOLD("%7d") " |" CYAN_BOLD("%3d") " |" CYAN_BOLD("%4d") " |" CYAN("%7zu") " | " GREEN_BOLD("%s"),
                        i,
                        data.thread.index(),
                        data.device.topology().toString().data(),

src/backend/cuda/wrappers/CudaDevice.cpp

@@ -5,8 +5,8 @@
  * 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 2018-2024 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright 2016-2024 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
@@ -22,7 +22,6 @@
  *   along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include "backend/cuda/wrappers/CudaDevice.h"
 #include "3rdparty/rapidjson/document.h"
 #include "backend/cuda/CudaThreads.h"
@@ -41,7 +40,7 @@
 xmrig::CudaDevice::CudaDevice(uint32_t index, int32_t bfactor, int32_t bsleep) :
     m_index(index)
 {
-    auto ctx = CudaLib::alloc(index, bfactor, bsleep);
+    auto *ctx = CudaLib::alloc(index, bfactor, bsleep);
     if (!CudaLib::deviceInfo(ctx, 0, 0, Algorithm::INVALID)) {
         CudaLib::release(ctx);
 
@@ -50,7 +49,7 @@ xmrig::CudaDevice::CudaDevice(uint32_t index, int32_t bfactor, int32_t bsleep) :
 
     m_ctx       = ctx;
     m_name      = CudaLib::deviceName(ctx);
-    m_topology  = PciTopology(CudaLib::deviceUint(ctx, CudaLib::DevicePciBusID), CudaLib::deviceUint(ctx, CudaLib::DevicePciDeviceID), 0);
+    m_topology  = { CudaLib::deviceUint(ctx, CudaLib::DevicePciBusID), CudaLib::deviceUint(ctx, CudaLib::DevicePciDeviceID), 0U };
 }
 
 

src/backend/opencl/opencl.cmake

@@ -5,13 +5,7 @@ if (BUILD_STATIC AND XMRIG_OS_UNIX AND WITH_OPENCL)
 endif()
 
 if (WITH_OPENCL)
-    add_definitions(/DXMRIG_FEATURE_OPENCL)
+    add_definitions(/DXMRIG_FEATURE_OPENCL /DCL_USE_DEPRECATED_OPENCL_1_2_APIS)
-    add_definitions(/DCL_USE_DEPRECATED_OPENCL_1_2_APIS)
-    if (XMRIG_OS_APPLE)
-        add_definitions(/DCL_TARGET_OPENCL_VERSION=120)
-    elseif (WITH_OPENCL_VERSION)
-        add_definitions(/DCL_TARGET_OPENCL_VERSION=${WITH_OPENCL_VERSION})
-    endif()
 
     set(HEADERS_BACKEND_OPENCL
         src/backend/opencl/cl/OclSource.h
@@ -71,6 +65,13 @@ if (WITH_OPENCL)
         src/backend/opencl/wrappers/OclPlatform.cpp
         )
 
+    if (XMRIG_OS_APPLE)
+        add_definitions(/DCL_TARGET_OPENCL_VERSION=120)
+        list(APPEND SOURCES_BACKEND_OPENCL src/backend/opencl/wrappers/OclDevice_mac.cpp)
+    elseif (WITH_OPENCL_VERSION)
+        add_definitions(/DCL_TARGET_OPENCL_VERSION=${WITH_OPENCL_VERSION})
+    endif()
+
     if (WIN32)
         list(APPEND SOURCES_BACKEND_OPENCL src/backend/opencl/OclCache_win.cpp)
     else()

src/backend/opencl/wrappers/OclDevice.cpp

@@ -1,6 +1,7 @@
 /* XMRig
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2021      Spudz76     <https://github.com/Spudz76>
- * Copyright (c) 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2024 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2024 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
@@ -17,6 +18,7 @@
  */
 
 #include "backend/opencl/wrappers/OclDevice.h"
+#include "3rdparty/fmt/core.h"
 #include "3rdparty/rapidjson/document.h"
 #include "backend/opencl/OclGenerator.h"
 #include "backend/opencl/OclThreads.h"
@@ -30,19 +32,21 @@
 
 
 #include <algorithm>
-
+#include <map>
-
-// NOLINTNEXTLINE(modernize-use-using)
-typedef union
-{
-    struct { cl_uint type; cl_uint data[5]; } raw;
-    struct { cl_uint type; cl_char unused[17]; cl_char bus; cl_char device; cl_char function; } pcie;
-} topology_amd;
 
 
 namespace xmrig {
 
 
+struct topology_amd {
+    cl_uint type;
+    cl_char unused[17];
+    cl_char bus;
+    cl_char device;
+    cl_char function;
+};
+
+
 #ifdef XMRIG_ALGO_RANDOMX
 extern bool ocl_generic_rx_generator(const OclDevice &device, const Algorithm &algorithm, OclThreads &threads);
 #endif
@@ -81,9 +85,11 @@ static OclVendor getPlatformVendorId(const String &vendor, const String &extensi
         return OCL_VENDOR_INTEL;
     }
 
+#   ifdef XMRIG_OS_APPLE
     if (extensions.contains("cl_APPLE_") || vendor.contains("Apple")) {
         return OCL_VENDOR_APPLE;
     }
+#   endif
 
     return OCL_VENDOR_UNKNOWN;
 }
@@ -103,117 +109,16 @@ static OclVendor getVendorId(const String &vendor)
         return OCL_VENDOR_INTEL;
     }
 
+#   ifdef XMRIG_OS_APPLE
     if (vendor.contains("Apple")) {
         return OCL_VENDOR_APPLE;
     }
+#   endif
 
     return OCL_VENDOR_UNKNOWN;
 }
 
 
-static OclDevice::Type getType(const String &name, const OclVendor platformVendorId)
-{
-    if (platformVendorId == OCL_VENDOR_APPLE) {
-        // Apple Platform: uses product names, not gfx# or codenames
-        if (name.contains("AMD Radeon")) {
-            if (name.contains(" 450 ") ||
-                name.contains(" 455 ") ||
-                name.contains(" 460 ")) {
-                return OclDevice::Baffin;
-            }
-
-            if (name.contains(" 555 ") || name.contains(" 555X ") ||
-                name.contains(" 560 ") || name.contains(" 560X ") ||
-                name.contains(" 570 ") || name.contains(" 570X ") ||
-                name.contains(" 575 ") || name.contains(" 575X ")) {
-                return OclDevice::Polaris;
-            }
-
-            if (name.contains(" 580 ") || name.contains(" 580X ")) {
-                return OclDevice::Ellesmere;
-            }
-
-            if (name.contains(" Vega ")) {
-                if (name.contains(" 48 ") ||
-                    name.contains(" 56 ") ||
-                    name.contains(" 64 ") ||
-                    name.contains(" 64X ")) {
-                    return OclDevice::Vega_10;
-                }
-                if (name.contains(" 16 ") ||
-                    name.contains(" 20 ") ||
-                    name.contains(" II ")) {
-                    return OclDevice::Vega_20;
-                }
-            }
-
-            if (name.contains(" 5700 ") || name.contains(" W5700X ")) {
-                return OclDevice::Navi_10;
-            }
-
-            if (name.contains(" 5600 ") || name.contains(" 5600M ")) {
-                return OclDevice::Navi_12;
-            }
-
-            if (name.contains(" 5300 ") || name.contains(" 5300M ") ||
-                name.contains(" 5500 ") || name.contains(" 5500M ")) {
-                return OclDevice::Navi_14;
-            }
-
-            if (name.contains(" W6800 ") || name.contains(" W6900X ")) {
-                return OclDevice::Navi_21;
-            }
-        }
-    }
-
-    if (name == "gfx900" || name == "gfx901") {
-        return OclDevice::Vega_10;
-    }
-
-    if (name == "gfx902" || name == "gfx903") {
-        return OclDevice::Raven;
-    }
-
-    if (name == "gfx906" || name == "gfx907") {
-        return OclDevice::Vega_20;
-    }
-
-    if (name == "gfx1010") {
-        return OclDevice::Navi_10;
-    }
-
-    if (name == "gfx1011") {
-        return OclDevice::Navi_12;
-    }
-
-    if (name == "gfx1012") {
-        return OclDevice::Navi_14;
-    }
-
-    if (name == "gfx1030") {
-        return OclDevice::Navi_21;
-    }
-
-    if (name == "gfx804") {
-        return OclDevice::Lexa;
-    }
-
-    if (name == "Baffin") {
-        return OclDevice::Baffin;
-    }
-
-    if (name.contains("Ellesmere")) {
-        return OclDevice::Ellesmere;
-    }
-
-    if (name == "gfx803" || name.contains("polaris")) {
-        return OclDevice::Polaris;
-    }
-
-    return OclDevice::Unknown;
-}
-
-
 } // namespace xmrig
 
 
@@ -231,21 +136,21 @@ xmrig::OclDevice::OclDevice(uint32_t index, cl_device_id id, cl_platform_id plat
 {
     m_vendorId  = getVendorId(m_vendor);
     m_platformVendorId = getPlatformVendorId(m_platformVendor, m_extensions);
-    m_type      = getType(m_name, m_platformVendorId);
+    m_type      = getType(m_name);
 
     if (m_extensions.contains("cl_amd_device_attribute_query")) {
-        topology_amd topology;
+        topology_amd topology{};
-
+        if (OclLib::getDeviceInfo(id, CL_DEVICE_TOPOLOGY_AMD, sizeof(topology), &topology) == CL_SUCCESS && topology.type == CL_DEVICE_TOPOLOGY_TYPE_PCIE_AMD) {
-        if (OclLib::getDeviceInfo(id, CL_DEVICE_TOPOLOGY_AMD, sizeof(topology), &topology, nullptr) == CL_SUCCESS && topology.raw.type == CL_DEVICE_TOPOLOGY_TYPE_PCIE_AMD) {
+            m_topology = { topology.bus, topology.device, topology.function };
-            m_topology = PciTopology(static_cast<uint32_t>(topology.pcie.bus), static_cast<uint32_t>(topology.pcie.device), static_cast<uint32_t>(topology.pcie.function));
         }
+
         m_board = OclLib::getString(id, CL_DEVICE_BOARD_NAME_AMD);
     }
     else if (m_extensions.contains("cl_nv_device_attribute_query")) {
         cl_uint bus = 0;
-        if (OclLib::getDeviceInfo(id, CL_DEVICE_PCI_BUS_ID_NV, sizeof (bus), &bus, nullptr) == CL_SUCCESS) {
+        if (OclLib::getDeviceInfo(id, CL_DEVICE_PCI_BUS_ID_NV, sizeof(bus), &bus) == CL_SUCCESS) {
             cl_uint slot  = OclLib::getUint(id, CL_DEVICE_PCI_SLOT_ID_NV);
-            m_topology = PciTopology(bus, (slot >> 3) & 0xff, slot & 7);
+            m_topology = { bus, (slot >> 3) & 0xff, slot & 7 };
         }
     }
 }
@@ -253,17 +158,11 @@ xmrig::OclDevice::OclDevice(uint32_t index, cl_device_id id, cl_platform_id plat
 
 xmrig::String xmrig::OclDevice::printableName() const
 {
-    const size_t size = m_board.size() + m_name.size() + 64;
-    char *buf         = new char[size]();
-
     if (m_board.isNull()) {
-        snprintf(buf, size, GREEN_BOLD("%s"), m_name.data());
+        return fmt::format(GREEN_BOLD("{}"), m_name).c_str();
-    }
-    else {
-        snprintf(buf, size, GREEN_BOLD("%s") " (" CYAN_BOLD("%s") ")", m_board.data(), m_name.data());
     }
 
-    return buf;
+    return fmt::format(GREEN_BOLD("{}") " (" CYAN_BOLD("{}") ")", m_board, m_name).c_str();
 }
 
 
@@ -311,3 +210,35 @@ void xmrig::OclDevice::toJSON(rapidjson::Value &out, rapidjson::Document &doc) c
 #   endif
 }
 #endif
+
+
+#ifndef XMRIG_OS_APPLE
+xmrig::OclDevice::Type xmrig::OclDevice::getType(const String &name)
+{
+    static std::map<const char *, OclDevice::Type> types = {
+        { "gfx900",     Vega_10 },
+        { "gfx901",     Vega_10 },
+        { "gfx902",     Raven },
+        { "gfx903",     Raven },
+        { "gfx906",     Vega_20 },
+        { "gfx907",     Vega_20 },
+        { "gfx1010",    Navi_10 },
+        { "gfx1011",    Navi_12 },
+        { "gfx1012",    Navi_14 },
+        { "gfx1030",    Navi_21 },
+        { "gfx804",     Lexa },
+        { "Baffin",     Baffin },
+        { "Ellesmere",  Ellesmere },
+        { "gfx803",     Polaris },
+        { "polaris",    Polaris },
+    };
+
+    for (auto &kv : types) {
+        if (name.contains(kv.first)) {
+            return kv.second;
+        }
+    }
+
+    return OclDevice::Unknown;
+}
+#endif

src/backend/opencl/wrappers/OclDevice.h

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2018-2024 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2016-2024 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
@@ -86,6 +86,8 @@ public:
 #   endif
 
 private:
+    static OclDevice::Type getType(const String &name);
+
     cl_device_id m_id               = nullptr;
     cl_platform_id m_platform       = nullptr;
     const String m_platformVendor;

src/backend/opencl/wrappers/OclDevice_mac.cpp

@@ -0,0 +1,77 @@
+/* XMRig
+ * Copyright (c) 2021      Spudz76     <https://github.com/Spudz76>
+ * Copyright (c) 2018-2024 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2024 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/opencl/wrappers/OclDevice.h"
+
+
+xmrig::OclDevice::Type xmrig::OclDevice::getType(const String &name)
+{
+    // Apple Platform: uses product names, not gfx# or codenames
+    if (name.contains("AMD Radeon")) {
+        if (name.contains(" 450 ") ||
+            name.contains(" 455 ") ||
+            name.contains(" 460 ")) {
+            return Baffin;
+        }
+
+        if (name.contains(" 555 ") || name.contains(" 555X ") ||
+            name.contains(" 560 ") || name.contains(" 560X ") ||
+            name.contains(" 570 ") || name.contains(" 570X ") ||
+            name.contains(" 575 ") || name.contains(" 575X ")) {
+            return Polaris;
+        }
+
+        if (name.contains(" 580 ") || name.contains(" 580X ")) {
+            return Ellesmere;
+        }
+
+        if (name.contains(" Vega ")) {
+            if (name.contains(" 48 ") ||
+                name.contains(" 56 ") ||
+                name.contains(" 64 ") ||
+                name.contains(" 64X ")) {
+                return Vega_10;
+            }
+            if (name.contains(" 16 ") ||
+                name.contains(" 20 ") ||
+                name.contains(" II ")) {
+                return Vega_20;
+            }
+        }
+
+        if (name.contains(" 5700 ") || name.contains(" W5700X ")) {
+            return Navi_10;
+        }
+
+        if (name.contains(" 5600 ") || name.contains(" 5600M ")) {
+            return Navi_12;
+        }
+
+        if (name.contains(" 5300 ") || name.contains(" 5300M ") ||
+            name.contains(" 5500 ") || name.contains(" 5500M ")) {
+            return Navi_14;
+        }
+
+        if (name.contains(" W6800 ") || name.contains(" W6900X ")) {
+            return Navi_21;
+        }
+    }
+
+    return OclDevice::Unknown;
+}

src/crypto/cn/CnAlgo.h

@@ -37,14 +37,36 @@ class CnAlgo
 public:
     constexpr CnAlgo() {};
 
-    constexpr inline Algorithm::Id base() const  { static_assert(Algorithm::isCN(ALGO), "invalid CRYPTONIGHT algorithm"); return Algorithm::base(ALGO); }
+#   define ASSERT_CN static_assert(Algorithm::isCN(ALGO), "invalid CRYPTONIGHT algorithm")
-    constexpr inline bool isHeavy() const        { return Algorithm::family(ALGO) == Algorithm::CN_HEAVY; }
+    constexpr inline Algorithm::Id base() const  { ASSERT_CN; return Algorithm::base(ALGO); }
-    constexpr inline bool isR() const            { return ALGO == Algorithm::CN_R; }
+    constexpr inline size_t memory() const       { ASSERT_CN; return Algorithm::l3(ALGO); }
-    constexpr inline size_t memory() const       { static_assert(Algorithm::isCN(ALGO), "invalid CRYPTONIGHT algorithm"); return Algorithm::l3(ALGO); }
+    constexpr inline uint32_t iterations() const { ASSERT_CN; return CN_ITER; }
-    constexpr inline uint32_t iterations() const { static_assert(Algorithm::isCN(ALGO), "invalid CRYPTONIGHT algorithm"); return CN_ITER; }
     constexpr inline uint32_t mask() const       { return static_cast<uint32_t>(((memory() - 1) / 16) * 16); }
     constexpr inline uint32_t half_mem() const   { return mask() < memory() / 2; }
 
+    constexpr inline bool isBase1() const        { ASSERT_CN; return Algorithm::base(ALGO) == Algorithm::CN_1; }
+    constexpr inline bool isBase2() const        { ASSERT_CN; return Algorithm::base(ALGO) == Algorithm::CN_2; }
+    constexpr inline bool is2() const            { return ALGO == Algorithm::CN_2; }
+    constexpr inline bool isR() const            { return ALGO == Algorithm::CN_R; }
+    constexpr inline bool isHalf() const         { return ALGO == Algorithm::CN_HALF; }
+    constexpr inline bool isRTO() const          { return ALGO == Algorithm::CN_RTO; }
+    constexpr inline bool isRWZ() const          { return ALGO == Algorithm::CN_RWZ; }
+    constexpr inline bool isZLS() const          { return ALGO == Algorithm::CN_ZLS; }
+    constexpr inline bool isDouble() const       { return ALGO == Algorithm::CN_DOUBLE; }
+    constexpr inline bool isCCX() const          { return ALGO == Algorithm::CN_CCX; }
+    constexpr inline bool isHeavy() const        { ASSERT_CN; return Algorithm::family(ALGO) == Algorithm::CN_HEAVY; }
+    constexpr inline bool isHeavyTube() const    { return ALGO == Algorithm::CN_HEAVY_TUBE; }
+    constexpr inline bool isHeavyXHV() const     { return ALGO == Algorithm::CN_HEAVY_XHV; }
+    constexpr inline bool isPico0() const        { return ALGO == Algorithm::CN_PICO_0; }
+    constexpr inline bool isPicoTLO() const      { return ALGO == Algorithm::CN_PICO_TLO; }
+    constexpr inline bool isUPX2() const         { return ALGO == Algorithm::CN_UPX2; }
+    constexpr inline bool isGR0() const          { return ALGO == Algorithm::CN_GR_0; }
+    constexpr inline bool isGR1() const          { return ALGO == Algorithm::CN_GR_1; }
+    constexpr inline bool isGR2() const          { return ALGO == Algorithm::CN_GR_2; }
+    constexpr inline bool isGR3() const          { return ALGO == Algorithm::CN_GR_3; }
+    constexpr inline bool isGR4() const          { return ALGO == Algorithm::CN_GR_4; }
+    constexpr inline bool isGR5() const          { return ALGO == Algorithm::CN_GR_5; }
+
     inline static uint32_t iterations(Algorithm::Id algo)
     {
         switch (algo) {

src/crypto/cn/CryptoNight_x86.h

@@ -603,7 +603,7 @@ static inline void cryptonight_monero_tweak(uint64_t *mem_out, const uint8_t *l,
     constexpr CnAlgo<ALGO> props;
 
     if (props.base() == Algorithm::CN_2) {
-        VARIANT2_SHUFFLE(l, idx, ax0, bx0, bx1, cx, (((ALGO == Algorithm::CN_RWZ) || (ALGO == Algorithm::CN_UPX2)) ? 1 : 0));
+        VARIANT2_SHUFFLE(l, idx, ax0, bx0, bx1, cx, ((props.isRWZ() || props.isUPX2()) ? 1 : 0));
         _mm_store_si128(reinterpret_cast<__m128i *>(mem_out), _mm_xor_si128(bx0, cx));
     } else {
         __m128i tmp = _mm_xor_si128(bx0, cx);
@@ -665,15 +665,8 @@ inline void cryptonight_single_hash(const uint8_t *__restrict__ input, size_t si
 
     constexpr CnAlgo<ALGO> props;
     constexpr size_t MASK        = props.mask();
-    constexpr Algorithm::Id BASE = props.base();
 
-#   ifdef XMRIG_ALGO_CN_HEAVY
+    if (props.isBase1() && size < 43) {
-    constexpr bool IS_CN_HEAVY_TUBE = ALGO == Algorithm::CN_HEAVY_TUBE;
-#   else
-    constexpr bool IS_CN_HEAVY_TUBE = false;
-#   endif
-
-    if (BASE == Algorithm::CN_1 && size < 43) {
         memset(output, 0, 32);
         return;
     }
@@ -694,10 +687,7 @@ inline void cryptonight_single_hash(const uint8_t *__restrict__ input, size_t si
             V4_Instruction code[256];
             const int code_size = v4_random_math_init<ALGO>(code, height);
 
-            if (ALGO == Algorithm::CN_R) {
+            v4_soft_aes_compile_code(code, code_size, reinterpret_cast<void*>(ctx[0]->generated_code), Assembly::NONE);
-                v4_soft_aes_compile_code(code, code_size, reinterpret_cast<void*>(ctx[0]->generated_code), Assembly::NONE);
-            }
-
             ctx[0]->generated_code_data = { ALGO, height };
         }
 
@@ -718,26 +708,26 @@ inline void cryptonight_single_hash(const uint8_t *__restrict__ input, size_t si
     __m128i bx1   = _mm_set_epi64x(static_cast<int64_t>(h0[9] ^ h0[11]), static_cast<int64_t>(h0[8] ^ h0[10]));
 
     __m128 conc_var;
-    if (ALGO == Algorithm::CN_CCX) {
+    if (props.isCCX()) {
         conc_var = _mm_setzero_ps();
         RESTORE_ROUNDING_MODE();
     }
 
     for (size_t i = 0; i < props.iterations(); i++) {
         __m128i cx;
-        if (IS_CN_HEAVY_TUBE || !SOFT_AES) {
+        if (props.isHeavyTube() || !SOFT_AES) {
             cx = _mm_load_si128(reinterpret_cast<const __m128i *>(&l0[interleaved_index<interleave>(idx0 & MASK)]));
-            if (ALGO == Algorithm::CN_CCX) {
+            if (props.isCCX()) {
                 cryptonight_conceal_tweak(cx, conc_var);
             }
         }
 
         const __m128i ax0 = _mm_set_epi64x(static_cast<int64_t>(ah0), static_cast<int64_t>(al0));
-        if (IS_CN_HEAVY_TUBE) {
+        if (props.isHeavyTube()) {
             cx = aes_round_tweak_div(cx, ax0);
         }
         else if (SOFT_AES) {
-            if (ALGO == Algorithm::CN_CCX) {
+            if (props.isCCX()) {
                 cx = _mm_load_si128(reinterpret_cast<const __m128i*>(&l0[interleaved_index<interleave>(idx0 & MASK)]));
                 cryptonight_conceal_tweak(cx, conc_var);
                 cx = soft_aesenc(&cx, ax0, reinterpret_cast<const uint32_t*>(saes_table));
@@ -750,7 +740,7 @@ inline void cryptonight_single_hash(const uint8_t *__restrict__ input, size_t si
             cx = _mm_aesenc_si128(cx, ax0);
         }
 
-        if (BASE == Algorithm::CN_1 || BASE == Algorithm::CN_2) {
+        if (props.isBase1() || props.isBase2()) {
             cryptonight_monero_tweak<ALGO>(reinterpret_cast<uint64_t*>(&l0[interleaved_index<interleave>(idx0 & MASK)]), l0, idx0 & MASK, ax0, bx0, bx1, cx);
         } else {
             _mm_store_si128(reinterpret_cast<__m128i *>(&l0[interleaved_index<interleave>(idx0 & MASK)]), _mm_xor_si128(bx0, cx));
@@ -762,13 +752,11 @@ inline void cryptonight_single_hash(const uint8_t *__restrict__ input, size_t si
         cl = (reinterpret_cast<uint64_t*>(&l0[interleaved_index<interleave>(idx0 & MASK)]))[0];
         ch = (reinterpret_cast<uint64_t*>(&l0[interleaved_index<interleave>(idx0 & MASK)]))[1];
 
-        if (BASE == Algorithm::CN_2) {
+        if (props.isBase2()) {
             if (props.isR()) {
                 VARIANT4_RANDOM_MATH(0, al0, ah0, cl, bx0, bx1);
-                if (ALGO == Algorithm::CN_R) {
+                al0 ^= r0[2] | (static_cast<uint64_t>(r0[3]) << 32);
-                    al0 ^= r0[2] | (static_cast<uint64_t>(r0[3]) << 32);
+                ah0 ^= r0[0] | (static_cast<uint64_t>(r0[1]) << 32);
-                    ah0 ^= r0[0] | (static_cast<uint64_t>(r0[1]) << 32);
-                }
             } else {
                 VARIANT2_INTEGER_MATH(0, cl, cx);
             }
@@ -776,11 +764,11 @@ inline void cryptonight_single_hash(const uint8_t *__restrict__ input, size_t si
 
         lo = __umul128(idx0, cl, &hi);
 
-        if (BASE == Algorithm::CN_2) {
+        if (props.isBase2()) {
-            if (ALGO == Algorithm::CN_R) {
+            if (props.isR()) {
                 VARIANT2_SHUFFLE(l0, idx0 & MASK, ax0, bx0, bx1, cx, 0);
             } else {
-                VARIANT2_SHUFFLE2(l0, idx0 & MASK, ax0, bx0, bx1, hi, lo, (((ALGO == Algorithm::CN_RWZ) || (ALGO == Algorithm::CN_UPX2)) ? 1 : 0));
+                VARIANT2_SHUFFLE2(l0, idx0 & MASK, ax0, bx0, bx1, hi, lo, ((props.isRWZ() || props.isUPX2()) ? 1 : 0));
             }
         }
 
@@ -789,9 +777,9 @@ inline void cryptonight_single_hash(const uint8_t *__restrict__ input, size_t si
 
         reinterpret_cast<uint64_t*>(&l0[interleaved_index<interleave>(idx0 & MASK)])[0] = al0;
 
-        if (IS_CN_HEAVY_TUBE || ALGO == Algorithm::CN_RTO) {
+        if (props.isHeavyTube() || props.isRTO()) {
             reinterpret_cast<uint64_t*>(&l0[interleaved_index<interleave>(idx0 & MASK)])[1] = ah0 ^ tweak1_2_0 ^ al0;
-        } else if (BASE == Algorithm::CN_1) {
+        } else if (props.isBase1()) {
             reinterpret_cast<uint64_t*>(&l0[interleaved_index<interleave>(idx0 & MASK)])[1] = ah0 ^ tweak1_2_0;
         } else {
             reinterpret_cast<uint64_t*>(&l0[interleaved_index<interleave>(idx0 & MASK)])[1] = ah0;
@@ -819,7 +807,7 @@ inline void cryptonight_single_hash(const uint8_t *__restrict__ input, size_t si
 
             ((int64_t*)&l0[interleaved_index<interleave>(idx0 & MASK)])[0] = n ^ q;
 
-            if (ALGO == Algorithm::CN_HEAVY_XHV) {
+            if (props.isHeavyXHV()) {
                 d = ~d;
             }
 
@@ -827,7 +815,7 @@ inline void cryptonight_single_hash(const uint8_t *__restrict__ input, size_t si
         }
 #       endif
 
-        if (BASE == Algorithm::CN_2) {
+        if (props.isBase2()) {
             bx1 = bx0;
         }
 
@@ -960,7 +948,7 @@ inline void cryptonight_single_hash_asm(const uint8_t *__restrict__ input, size_
     }
     cn_explode_scratchpad<ALGO, false, 0>(ctx[0]);
 
-    if (ALGO == Algorithm::CN_2) {
+    if (props.is2()) {
         if (ASM == Assembly::INTEL) {
             cnv2_mainloop_ivybridge_asm(ctx);
         }
@@ -971,7 +959,7 @@ inline void cryptonight_single_hash_asm(const uint8_t *__restrict__ input, size_
             cnv2_mainloop_bulldozer_asm(ctx);
         }
     }
-    else if (ALGO == Algorithm::CN_HALF) {
+    else if (props.isHalf()) {
         if (ASM == Assembly::INTEL) {
             cn_half_mainloop_ivybridge_asm(ctx);
         }
@@ -983,7 +971,7 @@ inline void cryptonight_single_hash_asm(const uint8_t *__restrict__ input, size_
         }
     }
 #   ifdef XMRIG_ALGO_CN_PICO
-    else if (ALGO == Algorithm::CN_PICO_0) {
+    else if (props.isPico0()) {
         if (ASM == Assembly::INTEL) {
             cn_trtl_mainloop_ivybridge_asm(ctx);
         }
@@ -994,7 +982,7 @@ inline void cryptonight_single_hash_asm(const uint8_t *__restrict__ input, size_
             cn_trtl_mainloop_bulldozer_asm(ctx);
         }
     }
-    else if (ALGO == Algorithm::CN_PICO_TLO) {
+    else if (props.isPicoTLO()) {
         if (ASM == Assembly::INTEL) {
             cn_tlo_mainloop_ivybridge_asm(ctx);
         }
@@ -1006,10 +994,10 @@ inline void cryptonight_single_hash_asm(const uint8_t *__restrict__ input, size_
         }
     }
 #   endif
-    else if (ALGO == Algorithm::CN_RWZ) {
+    else if (props.isRWZ()) {
         cnv2_rwz_mainloop_asm(ctx);
     }
-    else if (ALGO == Algorithm::CN_ZLS) {
+    else if (props.isZLS()) {
         if (ASM == Assembly::INTEL) {
             cn_zls_mainloop_ivybridge_asm(ctx);
         }
@@ -1020,7 +1008,7 @@ inline void cryptonight_single_hash_asm(const uint8_t *__restrict__ input, size_
             cn_zls_mainloop_bulldozer_asm(ctx);
         }
     }
-    else if (ALGO == Algorithm::CN_DOUBLE) {
+    else if (props.isDouble()) {
         if (ASM == Assembly::INTEL) {
             cn_double_mainloop_ivybridge_asm(ctx);
         }
@@ -1032,7 +1020,7 @@ inline void cryptonight_single_hash_asm(const uint8_t *__restrict__ input, size_
         }
     }
 #   ifdef XMRIG_ALGO_CN_FEMTO
-    else if (ALGO == Algorithm::CN_UPX2) {
+    else if (props.isUPX2()) {
         cn_upx2_mainloop_asm(ctx);
     }
 #   endif
@@ -1078,22 +1066,22 @@ inline void cryptonight_double_hash_asm(const uint8_t *__restrict__ input, size_
         cn_explode_scratchpad<ALGO, false, 0>(ctx[1]);
     }
 
-    if (ALGO == Algorithm::CN_2) {
+    if (props.is2()) {
         cnv2_double_mainloop_sandybridge_asm(ctx);
     }
-    else if (ALGO == Algorithm::CN_HALF) {
+    else if (props.isHalf()){
         cn_half_double_mainloop_sandybridge_asm(ctx);
     }
 #   ifdef XMRIG_ALGO_CN_PICO
-    else if (ALGO == Algorithm::CN_PICO_0) {
+    else if (props.isPico0()) {
         cn_trtl_double_mainloop_sandybridge_asm(ctx);
     }
-    else if (ALGO == Algorithm::CN_PICO_TLO) {
+    else if (props.isPicoTLO()) {
         cn_tlo_double_mainloop_sandybridge_asm(ctx);
     }
 #   endif
 #   ifdef XMRIG_ALGO_CN_FEMTO
-    else if (ALGO == Algorithm::CN_UPX2) {
+    else if (props.isUPX2()) {
         if (Cpu::info()->arch() == ICpuInfo::ARCH_ZEN3) {
             cnv2_upx_double_mainloop_zen3_asm(ctx);
         }
@@ -1102,13 +1090,13 @@ inline void cryptonight_double_hash_asm(const uint8_t *__restrict__ input, size_
         }
     }
 #   endif
-    else if (ALGO == Algorithm::CN_RWZ) {
+    else if (props.isRWZ()) {
         cnv2_rwz_double_mainloop_asm(ctx);
     }
-    else if (ALGO == Algorithm::CN_ZLS) {
+    else if (props.isZLS()) {
         cn_zls_double_mainloop_sandybridge_asm(ctx);
     }
-    else if (ALGO == Algorithm::CN_DOUBLE) {
+    else if (props.isDouble()) {
         cn_double_double_mainloop_sandybridge_asm(ctx);
     }
     else if (props.isR()) {
@@ -1146,9 +1134,8 @@ template<Algorithm::Id ALGO>
 static NOINLINE void cryptonight_single_hash_gr_sse41(const uint8_t* __restrict__ input, size_t size, uint8_t* __restrict__ output, cryptonight_ctx** __restrict__ ctx, uint64_t height)
 {
     constexpr CnAlgo<ALGO> props;
-    constexpr Algorithm::Id BASE = props.base();
 
-    if (BASE == Algorithm::CN_1 && size < 43) {
+    if (props.isBase1() && size < 43) {
         memset(output, 0, 32);
         return;
     }
@@ -1163,12 +1150,12 @@ static NOINLINE void cryptonight_single_hash_gr_sse41(const uint8_t* __restrict_
     VARIANT1_INIT(0);
     ctx[0]->tweak1_2 = tweak1_2_0;
     ctx[0]->tweak1_table = tweak1_table;
-    if (ALGO == Algorithm::CN_GR_0) cn_gr0_single_mainloop_asm(ctx);
+    if (props.isGR0()) cn_gr0_single_mainloop_asm(ctx);
-    if (ALGO == Algorithm::CN_GR_1) cn_gr1_single_mainloop_asm(ctx);
+    if (props.isGR1()) cn_gr1_single_mainloop_asm(ctx);
-    if (ALGO == Algorithm::CN_GR_2) cn_gr2_single_mainloop_asm(ctx);
+    if (props.isGR2()) cn_gr2_single_mainloop_asm(ctx);
-    if (ALGO == Algorithm::CN_GR_3) cn_gr3_single_mainloop_asm(ctx);
+    if (props.isGR3()) cn_gr3_single_mainloop_asm(ctx);
-    if (ALGO == Algorithm::CN_GR_4) cn_gr4_single_mainloop_asm(ctx);
+    if (props.isGR4()) cn_gr4_single_mainloop_asm(ctx);
-    if (ALGO == Algorithm::CN_GR_5) cn_gr5_single_mainloop_asm(ctx);
+    if (props.isGR5()) cn_gr5_single_mainloop_asm(ctx);
 
     cn_implode_scratchpad<ALGO, false, 0>(ctx[0]);
     keccakf(reinterpret_cast<uint64_t*>(ctx[0]->state), 24);
@@ -1180,9 +1167,8 @@ template<Algorithm::Id ALGO>
 static NOINLINE void cryptonight_double_hash_gr_sse41(const uint8_t *__restrict__ input, size_t size, uint8_t *__restrict__ output, cryptonight_ctx **__restrict__ ctx, uint64_t height)
 {
     constexpr CnAlgo<ALGO> props;
-    constexpr Algorithm::Id BASE = props.base();
 
-    if (BASE == Algorithm::CN_1 && size < 43) {
+    if (props.isBase1() && size < 43) {
         memset(output, 0, 64);
         return;
     }
@@ -1196,7 +1182,7 @@ static NOINLINE void cryptonight_double_hash_gr_sse41(const uint8_t *__restrict_
     }
 
 #   ifdef XMRIG_VAES
-    if (!props.isHeavy() && cn_vaes_enabled) {
+    if (cn_vaes_enabled) {
         cn_explode_scratchpad_vaes_double(ctx[0], ctx[1], props.memory(), props.half_mem());
     }
     else
@@ -1214,15 +1200,15 @@ static NOINLINE void cryptonight_double_hash_gr_sse41(const uint8_t *__restrict_
 
     ctx[0]->tweak1_table = tweak1_table;
 
-    if (ALGO == Algorithm::CN_GR_0) cn_gr0_double_mainloop_asm(ctx);
+    if (props.isGR0()) cn_gr0_double_mainloop_asm(ctx);
-    if (ALGO == Algorithm::CN_GR_1) cn_gr1_double_mainloop_asm(ctx);
+    if (props.isGR1()) cn_gr1_double_mainloop_asm(ctx);
-    if (ALGO == Algorithm::CN_GR_2) cn_gr2_double_mainloop_asm(ctx);
+    if (props.isGR2()) cn_gr2_double_mainloop_asm(ctx);
-    if (ALGO == Algorithm::CN_GR_3) cn_gr3_double_mainloop_asm(ctx);
+    if (props.isGR3()) cn_gr3_double_mainloop_asm(ctx);
-    if (ALGO == Algorithm::CN_GR_4) cn_gr4_double_mainloop_asm(ctx);
+    if (props.isGR4()) cn_gr4_double_mainloop_asm(ctx);
-    if (ALGO == Algorithm::CN_GR_5) cn_gr5_double_mainloop_asm(ctx);
+    if (props.isGR5()) cn_gr5_double_mainloop_asm(ctx);
 
 #   ifdef XMRIG_VAES
-    if (!props.isHeavy() && cn_vaes_enabled) {
+    if (cn_vaes_enabled) {
         cn_implode_scratchpad_vaes_double(ctx[0], ctx[1], props.memory(), props.half_mem());
     }
     else
@@ -1267,15 +1253,8 @@ inline void cryptonight_double_hash(const uint8_t *__restrict__ input, size_t si
 
     constexpr CnAlgo<ALGO> props;
     constexpr size_t MASK        = props.mask();
-    constexpr Algorithm::Id BASE = props.base();
 
-#   ifdef XMRIG_ALGO_CN_HEAVY
+    if (props.isBase1() && size < 43) {
-    constexpr bool IS_CN_HEAVY_TUBE = ALGO == Algorithm::CN_HEAVY_TUBE;
-#   else
-    constexpr bool IS_CN_HEAVY_TUBE = false;
-#   endif
-
-    if (BASE == Algorithm::CN_1 && size < 43) {
         memset(output, 0, 64);
         return;
     }
@@ -1323,7 +1302,7 @@ inline void cryptonight_double_hash(const uint8_t *__restrict__ input, size_t si
     __m128i bx11 = _mm_set_epi64x(h1[9] ^ h1[11], h1[8] ^ h1[10]);
 
     __m128 conc_var0, conc_var1;
-    if (ALGO == Algorithm::CN_CCX) {
+    if (props.isCCX()) {
         conc_var0 = _mm_setzero_ps();
         conc_var1 = _mm_setzero_ps();
         RESTORE_ROUNDING_MODE();
@@ -1334,10 +1313,10 @@ inline void cryptonight_double_hash(const uint8_t *__restrict__ input, size_t si
 
     for (size_t i = 0; i < props.iterations(); i++) {
         __m128i cx0, cx1;
-        if (IS_CN_HEAVY_TUBE || !SOFT_AES) {
+        if (props.isHeavyTube() || !SOFT_AES) {
             cx0 = _mm_load_si128(reinterpret_cast<const __m128i *>(&l0[idx0 & MASK]));
             cx1 = _mm_load_si128(reinterpret_cast<const __m128i *>(&l1[idx1 & MASK]));
-            if (ALGO == Algorithm::CN_CCX) {
+            if (props.isCCX()) {
                 cryptonight_conceal_tweak(cx0, conc_var0);
                 cryptonight_conceal_tweak(cx1, conc_var1);
             }
@@ -1345,12 +1324,12 @@ inline void cryptonight_double_hash(const uint8_t *__restrict__ input, size_t si
 
         const __m128i ax0 = _mm_set_epi64x(ah0, al0);
         const __m128i ax1 = _mm_set_epi64x(ah1, al1);
-        if (IS_CN_HEAVY_TUBE) {
+        if (props.isHeavyTube()) {
             cx0 = aes_round_tweak_div(cx0, ax0);
             cx1 = aes_round_tweak_div(cx1, ax1);
         }
         else if (SOFT_AES) {
-            if (ALGO == Algorithm::CN_CCX) {
+            if (props.isCCX()) {
                 cx0 = _mm_load_si128(reinterpret_cast<const __m128i*>(&l0[idx0 & MASK]));
                 cx1 = _mm_load_si128(reinterpret_cast<const __m128i*>(&l1[idx1 & MASK]));
                 cryptonight_conceal_tweak(cx0, conc_var0);
@@ -1368,7 +1347,7 @@ inline void cryptonight_double_hash(const uint8_t *__restrict__ input, size_t si
             cx1 = _mm_aesenc_si128(cx1, ax1);
         }
 
-        if (BASE == Algorithm::CN_1 || BASE == Algorithm::CN_2) {
+        if (props.isBase1() || props.isBase2()) {
             cryptonight_monero_tweak<ALGO>((uint64_t*)&l0[idx0 & MASK], l0, idx0 & MASK, ax0, bx00, bx01, cx0);
             cryptonight_monero_tweak<ALGO>((uint64_t*)&l1[idx1 & MASK], l1, idx1 & MASK, ax1, bx10, bx11, cx1);
         } else {
@@ -1383,13 +1362,11 @@ inline void cryptonight_double_hash(const uint8_t *__restrict__ input, size_t si
         cl = ((uint64_t*) &l0[idx0 & MASK])[0];
         ch = ((uint64_t*) &l0[idx0 & MASK])[1];
 
-        if (BASE == Algorithm::CN_2) {
+        if (props.isBase2()) {
             if (props.isR()) {
                 VARIANT4_RANDOM_MATH(0, al0, ah0, cl, bx00, bx01);
-                if (ALGO == Algorithm::CN_R) {
+                al0 ^= r0[2] | ((uint64_t)(r0[3]) << 32);
-                    al0 ^= r0[2] | ((uint64_t)(r0[3]) << 32);
+                ah0 ^= r0[0] | ((uint64_t)(r0[1]) << 32);
-                    ah0 ^= r0[0] | ((uint64_t)(r0[1]) << 32);
-                }
             } else {
                 VARIANT2_INTEGER_MATH(0, cl, cx0);
             }
@@ -1397,11 +1374,11 @@ inline void cryptonight_double_hash(const uint8_t *__restrict__ input, size_t si
 
         lo = __umul128(idx0, cl, &hi);
 
-        if (BASE == Algorithm::CN_2) {
+        if (props.isBase2()) {
-            if (ALGO == Algorithm::CN_R) {
+            if (props.isR()) {
                 VARIANT2_SHUFFLE(l0, idx0 & MASK, ax0, bx00, bx01, cx0, 0);
             } else {
-                VARIANT2_SHUFFLE2(l0, idx0 & MASK, ax0, bx00, bx01, hi, lo, (((ALGO == Algorithm::CN_RWZ) || (ALGO == Algorithm::CN_UPX2)) ? 1 : 0));
+                VARIANT2_SHUFFLE2(l0, idx0 & MASK, ax0, bx00, bx01, hi, lo, ((props.isRWZ() || props.isUPX2()) ? 1 : 0));
             }
         }
 
@@ -1410,9 +1387,9 @@ inline void cryptonight_double_hash(const uint8_t *__restrict__ input, size_t si
 
         ((uint64_t*)&l0[idx0 & MASK])[0] = al0;
 
-        if (IS_CN_HEAVY_TUBE || ALGO == Algorithm::CN_RTO) {
+        if (props.isHeavyTube() || props.isRTO()) {
             ((uint64_t*) &l0[idx0 & MASK])[1] = ah0 ^ tweak1_2_0 ^ al0;
-        } else if (BASE == Algorithm::CN_1) {
+        } else if (props.isBase1()) {
             ((uint64_t*) &l0[idx0 & MASK])[1] = ah0 ^ tweak1_2_0;
         } else {
             ((uint64_t*) &l0[idx0 & MASK])[1] = ah0;
@@ -1430,7 +1407,7 @@ inline void cryptonight_double_hash(const uint8_t *__restrict__ input, size_t si
 
             ((int64_t*)&l0[idx0 & MASK])[0] = n ^ q;
 
-            if (ALGO == Algorithm::CN_HEAVY_XHV) {
+            if (props.isHeavyXHV()) {
                 d = ~d;
             }
 
@@ -1441,13 +1418,11 @@ inline void cryptonight_double_hash(const uint8_t *__restrict__ input, size_t si
         cl = ((uint64_t*) &l1[idx1 & MASK])[0];
         ch = ((uint64_t*) &l1[idx1 & MASK])[1];
 
-        if (BASE == Algorithm::CN_2) {
+        if (props.isBase2()) {
             if (props.isR()) {
                 VARIANT4_RANDOM_MATH(1, al1, ah1, cl, bx10, bx11);
-                if (ALGO == Algorithm::CN_R) {
+                al1 ^= r1[2] | ((uint64_t)(r1[3]) << 32);
-                    al1 ^= r1[2] | ((uint64_t)(r1[3]) << 32);
+                ah1 ^= r1[0] | ((uint64_t)(r1[1]) << 32);
-                    ah1 ^= r1[0] | ((uint64_t)(r1[1]) << 32);
-                }
             } else {
                 VARIANT2_INTEGER_MATH(1, cl, cx1);
             }
@@ -1455,11 +1430,11 @@ inline void cryptonight_double_hash(const uint8_t *__restrict__ input, size_t si
 
         lo = __umul128(idx1, cl, &hi);
 
-        if (BASE == Algorithm::CN_2) {
+        if (props.isBase2()) {
-            if (ALGO == Algorithm::CN_R) {
+            if (props.isR()) {
                 VARIANT2_SHUFFLE(l1, idx1 & MASK, ax1, bx10, bx11, cx1, 0);
             } else {
-                VARIANT2_SHUFFLE2(l1, idx1 & MASK, ax1, bx10, bx11, hi, lo, (((ALGO == Algorithm::CN_RWZ) || (ALGO == Algorithm::CN_UPX2)) ? 1 : 0));
+                VARIANT2_SHUFFLE2(l1, idx1 & MASK, ax1, bx10, bx11, hi, lo, ((props.isRWZ() || props.isUPX2()) ? 1 : 0));
             }
         }
 
@@ -1468,9 +1443,9 @@ inline void cryptonight_double_hash(const uint8_t *__restrict__ input, size_t si
 
         ((uint64_t*)&l1[idx1 & MASK])[0] = al1;
 
-        if (IS_CN_HEAVY_TUBE || ALGO == Algorithm::CN_RTO) {
+        if (props.isHeavyTube() || props.isRTO()) {
             ((uint64_t*)&l1[idx1 & MASK])[1] = ah1 ^ tweak1_2_1 ^ al1;
-        } else if (BASE == Algorithm::CN_1) {
+        } else if (props.isBase1()) {
             ((uint64_t*)&l1[idx1 & MASK])[1] = ah1 ^ tweak1_2_1;
         } else {
             ((uint64_t*)&l1[idx1 & MASK])[1] = ah1;
@@ -1488,7 +1463,7 @@ inline void cryptonight_double_hash(const uint8_t *__restrict__ input, size_t si
 
             ((int64_t*)&l1[idx1 & MASK])[0] = n ^ q;
 
-            if (ALGO == Algorithm::CN_HEAVY_XHV) {
+            if (props.isHeavyXHV()) {
                 d = ~d;
             }
 
@@ -1496,7 +1471,7 @@ inline void cryptonight_double_hash(const uint8_t *__restrict__ input, size_t si
         }
 #       endif
 
-        if (BASE == Algorithm::CN_2) {
+        if (props.isBase2()) {
             bx01 = bx00;
             bx11 = bx10;
         }
@@ -1529,9 +1504,8 @@ template<Algorithm::Id ALGO>
 static NOINLINE void cryptonight_quad_hash_gr_sse41(const uint8_t* __restrict__ input, size_t size, uint8_t* __restrict__ output, cryptonight_ctx** __restrict__ ctx, uint64_t height)
 {
     constexpr CnAlgo<ALGO> props;
-    constexpr Algorithm::Id BASE = props.base();
 
-    if (BASE == Algorithm::CN_1 && size < 43) {
+    if (props.isBase1() && size < 43) {
         memset(output, 0, 32 * 4);
         return;
     }
@@ -1549,7 +1523,7 @@ static NOINLINE void cryptonight_quad_hash_gr_sse41(const uint8_t* __restrict__
     }
 
 #   ifdef XMRIG_VAES
-    if (!props.isHeavy() && cn_vaes_enabled) {
+    if (cn_vaes_enabled) {
         cn_explode_scratchpad_vaes_double(ctx[0], ctx[1], props.memory(), props.half_mem());
         cn_explode_scratchpad_vaes_double(ctx[2], ctx[3], props.memory(), props.half_mem());
     }
@@ -1569,15 +1543,15 @@ static NOINLINE void cryptonight_quad_hash_gr_sse41(const uint8_t* __restrict__
 
     ctx[0]->tweak1_table = tweak1_table;
 
-    if (ALGO == Algorithm::CN_GR_0) cn_gr0_quad_mainloop_asm(ctx);
+    if (props.isGR0()) cn_gr0_quad_mainloop_asm(ctx);
-    if (ALGO == Algorithm::CN_GR_1) cn_gr1_quad_mainloop_asm(ctx);
+    if (props.isGR1()) cn_gr1_quad_mainloop_asm(ctx);
-    if (ALGO == Algorithm::CN_GR_2) cn_gr2_quad_mainloop_asm(ctx);
+    if (props.isGR2()) cn_gr2_quad_mainloop_asm(ctx);
-    if (ALGO == Algorithm::CN_GR_3) cn_gr3_quad_mainloop_asm(ctx);
+    if (props.isGR3()) cn_gr3_quad_mainloop_asm(ctx);
-    if (ALGO == Algorithm::CN_GR_4) cn_gr4_quad_mainloop_asm(ctx);
+    if (props.isGR4()) cn_gr4_quad_mainloop_asm(ctx);
-    if (ALGO == Algorithm::CN_GR_5) cn_gr5_quad_mainloop_asm(ctx);
+    if (props.isGR5()) cn_gr5_quad_mainloop_asm(ctx);
 
 #   ifdef XMRIG_VAES
-    if (!props.isHeavy() && cn_vaes_enabled) {
+    if (cn_vaes_enabled) {
         cn_implode_scratchpad_vaes_double(ctx[0], ctx[1], props.memory(), props.half_mem());
         cn_implode_scratchpad_vaes_double(ctx[2], ctx[3], props.memory(), props.half_mem());
     }
@@ -1606,14 +1580,14 @@ static NOINLINE void cryptonight_quad_hash_gr_sse41(const uint8_t* __restrict__
 #define CN_STEP1(a, b0, b1, c, l, ptr, idx, conc_var) \
     ptr = reinterpret_cast<__m128i*>(&l[idx & MASK]); \
     c = _mm_load_si128(ptr);                          \
-    if (ALGO == Algorithm::CN_CCX) {                  \
+    if (props.isCCX()) {                              \
         cryptonight_conceal_tweak(c, conc_var);       \
     }
 
 
 
 #define CN_STEP2(a, b0, b1, c, l, ptr, idx)                                             \
-    if (IS_CN_HEAVY_TUBE) {                                                             \
+    if (props.isHeavyTube()) {                                                          \
         c = aes_round_tweak_div(c, a);                                                  \
     }                                                                                   \
     else if (SOFT_AES) {                                                                \
@@ -1622,7 +1596,7 @@ static NOINLINE void cryptonight_quad_hash_gr_sse41(const uint8_t* __restrict__
         c = _mm_aesenc_si128(c, a);                                                     \
     }                                                                                   \
                                                                                         \
-    if (BASE == Algorithm::CN_1 || BASE == Algorithm::CN_2) {                           \
+    if (props.isBase1() || props.isBase2()) {                                           \
         cryptonight_monero_tweak<ALGO>((uint64_t*)ptr, l, idx & MASK, a, b0, b1, c);    \
     } else {                                                                            \
         _mm_store_si128(ptr, _mm_xor_si128(b0, c));                                     \
@@ -1638,36 +1612,34 @@ static NOINLINE void cryptonight_quad_hash_gr_sse41(const uint8_t* __restrict__
 
 #define CN_STEP4(part, a, b0, b1, c, l, mc, ptr, idx)                                                       \
     uint64_t al##part, ah##part;                                                                            \
-    if (BASE == Algorithm::CN_2) {                                                                          \
+    if (props.isBase2()) {                                                                                  \
         if (props.isR()) {                                                                                  \
             al##part = _mm_cvtsi128_si64(a);                                                                \
             ah##part = _mm_cvtsi128_si64(_mm_srli_si128(a, 8));                                             \
             VARIANT4_RANDOM_MATH(part, al##part, ah##part, cl##part, b0, b1);                               \
-            if (ALGO == Algorithm::CN_R) {                                                                  \
+            al##part ^= r##part[2] | ((uint64_t)(r##part[3]) << 32);                                        \
-                al##part ^= r##part[2] | ((uint64_t)(r##part[3]) << 32);                                    \
+            ah##part ^= r##part[0] | ((uint64_t)(r##part[1]) << 32);                                        \
-                ah##part ^= r##part[0] | ((uint64_t)(r##part[1]) << 32);                                    \
-            }                                                                                               \
         } else {                                                                                            \
             VARIANT2_INTEGER_MATH(part, cl##part, c);                                                       \
         }                                                                                                   \
     }                                                                                                       \
     lo = __umul128(idx, cl##part, &hi);                                                                     \
-    if (BASE == Algorithm::CN_2) {                                                                          \
+    if (props.isBase2()) {                                                                                  \
-        if (ALGO == Algorithm::CN_R) {                                                                      \
+        if (props.isR()) {                                                                                  \
             VARIANT2_SHUFFLE(l, idx & MASK, a, b0, b1, c, 0);                                               \
         } else {                                                                                            \
-            VARIANT2_SHUFFLE2(l, idx & MASK, a, b0, b1, hi, lo, (((ALGO == Algorithm::CN_RWZ) || (ALGO == Algorithm::CN_UPX2)) ? 1 : 0)); \
+            VARIANT2_SHUFFLE2(l, idx & MASK, a, b0, b1, hi, lo, ((props.isRWZ() || props.isUPX2()) ? 1 : 0)); \
         }                                                                                                   \
     }                                                                                                       \
-    if (ALGO == Algorithm::CN_R) {                                                                          \
+    if (props.isR()) {                                                                                      \
         a = _mm_set_epi64x(ah##part, al##part);                                                             \
     }                                                                                                       \
     a = _mm_add_epi64(a, _mm_set_epi64x(lo, hi));                                                           \
                                                                                                             \
-    if (BASE == Algorithm::CN_1) {                                                                          \
+    if (props.isBase1()) {                                                                                  \
         _mm_store_si128(ptr, _mm_xor_si128(a, mc));                                                         \
                                                                                                             \
-        if (IS_CN_HEAVY_TUBE || ALGO == Algorithm::CN_RTO) {                                                \
+        if (props.isHeavyTube() || props.isRTO()) {                                                         \
             ((uint64_t*)ptr)[1] ^= ((uint64_t*)ptr)[0];                                                     \
         }                                                                                                   \
     } else {                                                                                                \
@@ -1681,13 +1653,13 @@ static NOINLINE void cryptonight_quad_hash_gr_sse41(const uint8_t* __restrict__
         int32_t d = ((int32_t*)&l[idx & MASK])[2];                                                          \
         int64_t q = n / (d | 0x5);                                                                          \
         ((int64_t*)&l[idx & MASK])[0] = n ^ q;                                                              \
-        if (IS_CN_HEAVY_XHV) {                                                                              \
+        if (props.isHeavyXHV()) {                                                                           \
             d = ~d;                                                                                         \
         }                                                                                                   \
                                                                                                             \
         idx = d ^ q;                                                                                        \
     }                                                                                                       \
-    if (BASE == Algorithm::CN_2) {                                                                          \
+    if (props.isBase2()) {                                                                                  \
         b1 = b0;                                                                                            \
     }                                                                                                       \
     b0 = c;
@@ -1697,11 +1669,11 @@ static NOINLINE void cryptonight_quad_hash_gr_sse41(const uint8_t* __restrict__
     __m128i mc##n;                                                                               \
     __m128i division_result_xmm_##n;                                                             \
     __m128i sqrt_result_xmm_##n;                                                                 \
-    if (BASE == Algorithm::CN_1) {                                                               \
+    if (props.isBase1()) {                                                                       \
         mc##n = _mm_set_epi64x(*reinterpret_cast<const uint64_t*>(input + n * size + 35) ^       \
                                *(reinterpret_cast<const uint64_t*>((ctx)->state) + 24), 0);      \
     }                                                                                            \
-    if (BASE == Algorithm::CN_2) {                                                               \
+    if (props.isBase2()) {                                                                       \
         division_result_xmm_##n = _mm_cvtsi64_si128(h##n[12]);                                   \
         sqrt_result_xmm_##n = _mm_cvtsi64_si128(h##n[13]);                                       \
     }                                                                                            \
@@ -1710,7 +1682,7 @@ static NOINLINE void cryptonight_quad_hash_gr_sse41(const uint8_t* __restrict__
     __m128i bx##n##1 = _mm_set_epi64x(h##n[9] ^ h##n[11], h##n[8] ^ h##n[10]);                   \
     __m128i cx##n = _mm_setzero_si128();                                                         \
     __m128 conc_var##n;                                                                          \
-    if (ALGO == Algorithm::CN_CCX) {                                                             \
+    if (props.isCCX()) {                                                                         \
         conc_var##n = _mm_setzero_ps();                                                          \
     }                                                                                            \
     VARIANT4_RANDOM_MATH_INIT(n);
@@ -1721,17 +1693,8 @@ inline void cryptonight_triple_hash(const uint8_t *__restrict__ input, size_t si
 {
     constexpr CnAlgo<ALGO> props;
     constexpr size_t MASK        = props.mask();
-    constexpr Algorithm::Id BASE = props.base();
 
-#   ifdef XMRIG_ALGO_CN_HEAVY
+    if (props.isBase1() && size < 43) {
-    constexpr bool IS_CN_HEAVY_TUBE = ALGO == Algorithm::CN_HEAVY_TUBE;
-    constexpr bool IS_CN_HEAVY_XHV  = ALGO == Algorithm::CN_HEAVY_XHV;
-#   else
-    constexpr bool IS_CN_HEAVY_TUBE = false;
-    constexpr bool IS_CN_HEAVY_XHV  = false;
-#   endif
-
-    if (BASE == Algorithm::CN_1 && size < 43) {
         memset(output, 0, 32 * 3);
         return;
     }
@@ -1755,7 +1718,7 @@ inline void cryptonight_triple_hash(const uint8_t *__restrict__ input, size_t si
     CONST_INIT(ctx[1], 1);
     CONST_INIT(ctx[2], 2);
     VARIANT2_SET_ROUNDING_MODE();
-    if (ALGO == Algorithm::CN_CCX) {
+    if (props.isCCX()) {
         RESTORE_ROUNDING_MODE();
     }
 
@@ -1819,17 +1782,8 @@ inline void cryptonight_quad_hash(const uint8_t *__restrict__ input, size_t size
 
     constexpr CnAlgo<ALGO> props;
     constexpr size_t MASK        = props.mask();
-    constexpr Algorithm::Id BASE = props.base();
 
-#   ifdef XMRIG_ALGO_CN_HEAVY
+    if (props.isBase1() && size < 43) {
-    constexpr bool IS_CN_HEAVY_TUBE = ALGO == Algorithm::CN_HEAVY_TUBE;
-    constexpr bool IS_CN_HEAVY_XHV  = ALGO == Algorithm::CN_HEAVY_XHV;
-#   else
-    constexpr bool IS_CN_HEAVY_TUBE = false;
-    constexpr bool IS_CN_HEAVY_XHV  = false;
-#   endif
-
-    if (BASE == Algorithm::CN_1 && size < 43) {
         memset(output, 0, 32 * 4);
         return;
     }
@@ -1869,7 +1823,7 @@ inline void cryptonight_quad_hash(const uint8_t *__restrict__ input, size_t size
     CONST_INIT(ctx[2], 2);
     CONST_INIT(ctx[3], 3);
     VARIANT2_SET_ROUNDING_MODE();
-    if (ALGO == Algorithm::CN_CCX) {
+    if (props.isCCX()) {
         RESTORE_ROUNDING_MODE();
     }
 
@@ -1930,17 +1884,8 @@ inline void cryptonight_penta_hash(const uint8_t *__restrict__ input, size_t siz
 {
     constexpr CnAlgo<ALGO> props;
     constexpr size_t MASK        = props.mask();
-    constexpr Algorithm::Id BASE = props.base();
 
-#   ifdef XMRIG_ALGO_CN_HEAVY
+    if (props.isBase1() && size < 43) {
-    constexpr bool IS_CN_HEAVY_TUBE = ALGO == Algorithm::CN_HEAVY_TUBE;
-    constexpr bool IS_CN_HEAVY_XHV  = ALGO == Algorithm::CN_HEAVY_XHV;
-#   else
-    constexpr bool IS_CN_HEAVY_TUBE = false;
-    constexpr bool IS_CN_HEAVY_XHV  = false;
-#   endif
-
-    if (BASE == Algorithm::CN_1 && size < 43) {
         memset(output, 0, 32 * 5);
         return;
     }
@@ -1970,7 +1915,7 @@ inline void cryptonight_penta_hash(const uint8_t *__restrict__ input, size_t siz
     CONST_INIT(ctx[3], 3);
     CONST_INIT(ctx[4], 4);
     VARIANT2_SET_ROUNDING_MODE();
-    if (ALGO == Algorithm::CN_CCX) {
+    if (props.isCCX()) {
         RESTORE_ROUNDING_MODE();
     }
 

src/version.h

@@ -22,7 +22,7 @@
 #define APP_ID        "xmrig"
 #define APP_NAME      "XMRig"
 #define APP_DESC      "XMRig miner"
-#define APP_VERSION   "6.22.2"
+#define APP_VERSION   "6.22.3-dev"
 #define APP_DOMAIN    "xmrig.com"
 #define APP_SITE      "www.xmrig.com"
 #define APP_COPYRIGHT "Copyright (C) 2016-2024 xmrig.com"
@@ -30,7 +30,7 @@
 
 #define APP_VER_MAJOR  6
 #define APP_VER_MINOR  22
-#define APP_VER_PATCH  2
+#define APP_VER_PATCH  3
 
 #ifdef _MSC_VER
 #   if (_MSC_VER >= 1930)