Merge 753e63cd96 into 64f5bb467a

Enabled keepalive for Windows (>= Vista)

CHANGELOG.md

@@ -1,3 +1,20 @@
+# v6.20.0
+- Added new ARM CPU names.
+- [#2394](https://github.com/xmrig/xmrig/pull/2394) Added new CMake options `ARM_V8` and `ARM_V7`.
+- [#2830](https://github.com/xmrig/xmrig/pull/2830) Added API rebind polling.
+- [#2927](https://github.com/xmrig/xmrig/pull/2927) Fixed compatibility with hwloc 1.11.x.
+- [#3060](https://github.com/xmrig/xmrig/pull/3060) Added x86 to `README.md`.
+- [#3236](https://github.com/xmrig/xmrig/pull/3236) Fixed: receive CUDA loader error on Linux too.
+- [#3290](https://github.com/xmrig/xmrig/pull/3290) Added [Zephyr](https://www.zephyrprotocol.com/) coin support for solo mining.
+
+# v6.19.3
+- [#3245](https://github.com/xmrig/xmrig/issues/3245) Improved algorithm negotiation for donation rounds by sending extra information about current mining job.
+- [#3254](https://github.com/xmrig/xmrig/pull/3254) Tweaked auto-tuning for Intel CPUs.
+- [#3271](https://github.com/xmrig/xmrig/pull/3271) RandomX: optimized program generation.
+- [#3273](https://github.com/xmrig/xmrig/pull/3273) RandomX: fixed undefined behavior.
+- [#3275](https://github.com/xmrig/xmrig/pull/3275) RandomX: fixed `jccErratum` list.
+- [#3280](https://github.com/xmrig/xmrig/pull/3280) Updated example scripts.
+
 # v6.19.2
 - [#3230](https://github.com/xmrig/xmrig/pull/3230) Fixed parsing of `TX_EXTRA_MERGE_MINING_TAG`.
 - [#3232](https://github.com/xmrig/xmrig/pull/3232) Added new `X-Hash-Difficulty` HTTP header.

CMakeLists.txt

@@ -34,7 +34,8 @@ option(WITH_SECURE_JIT      "Enable secure access to JIT memory" OFF)
 option(WITH_DMI             "Enable DMI/SMBIOS reader" ON)
 
 option(BUILD_STATIC         "Build static binary" OFF)
-option(ARM_TARGET           "Force use specific ARM target 8 or 7" 0)
+option(ARM_V8               "Force ARMv8 (64 bit) architecture, use with caution if automatic detection fails, but you sure it may work" OFF)
+option(ARM_V7               "Force ARMv7 (32 bit) architecture, use with caution if automatic detection fails, but you sure it may work" OFF)
 option(HWLOC_DEBUG          "Enable hwloc debug helpers and log" OFF)
 
 

README.md

@@ -10,7 +10,7 @@
 XMRig is a high performance, open source, cross platform RandomX, KawPow, CryptoNight and [GhostRider](https://github.com/xmrig/xmrig/tree/master/src/crypto/ghostrider#readme) unified CPU/GPU miner and [RandomX benchmark](https://xmrig.com/benchmark). Official binaries are available for Windows, Linux, macOS and FreeBSD.
 
 ## Mining backends
-- **CPU** (x64/ARMv7/ARMv8)
+- **CPU** (x86/x64/ARMv7/ARMv8)
 - **OpenCL** for AMD GPUs.
 - **CUDA** for NVIDIA GPUs via external [CUDA plugin](https://github.com/xmrig/xmrig-cuda).
 

cmake/cpu.cmake

@@ -29,6 +29,12 @@ else()
     set(WITH_VAES OFF)
 endif()
 
+if (ARM_V8)
+    set(ARM_TARGET 8)
+elseif (ARM_V7)
+    set(ARM_TARGET 7)
+endif()
+
 if (NOT ARM_TARGET)
     if (CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64|arm64|armv8-a)$")
         set(ARM_TARGET 8)

doc/API.md

@@ -4,7 +4,7 @@ If you want use HTTP API you need enable it (`"enabled": true,`) then choice `po
 
 Offical HTTP client for API: http://workers.xmrig.info/
 
-Example configuration:
+Example configuration, used in Curl examples below:
 
 ```json
 "api": {
@@ -12,11 +12,11 @@ Example configuration:
 	"worker-id": null,
 },
 "http": {
-	"enabled": false,
+	"enabled": true,
 	"host": "127.0.0.1",
-	"port": 0,
+	"port": 44444,
-	"access-token": null,
+	"access-token": "SECRET",
-	"restricted": true
+	"restricted": false
 }
 ```
 
@@ -37,30 +37,78 @@ Versions before 2.15 was use another options for API https://github.com/xmrig/xm
 
 ## Endpoints
 
-### GET /1/summary
+### APIVersion 2
 
-Get miner summary information. [Example](api/1/summary.json).
+#### GET /2/summary
 
-### GET /1/threads
+Get miner summary information. [Example](api/2/summary.json).
 
-Get detailed information about miner threads. [Example](api/1/threads.json).
+#### GET /2/backends
+
+Get detailed information about miner backends. [Example](api/2/backends.json).
+
+### APIVersion 1 (deprecated)
+
+#### GET /1/summary
+
+Get miner summary information. Currently identical to `GET /2/summary`
+
+#### GET /1/threads
+
+**REMOVED** Get detailed information about miner threads. [Example](api/1/threads.json).
+
+Functionally replaced by `GET /2/backends` which contains a `threads` item per backend.
+
+### APIVersion 0 (deprecated)
+
+#### GET /api.json
+
+Get miner summary information. Currently identical to `GET /2/summary`
 
 
 ## Restricted endpoints
 
 All API endpoints below allow access to sensitive information and remote configure miner. You should set `access-token` and allow unrestricted access (`"restricted": false`).
 
-### GET /1/config
+### JSON-RPC Interface
 
-Get current miner configuration. [Example](api/1/config.json).
+#### POST /json_rpc
 
+Control miner with JSON-RPC. Methods: `pause`, `resume`, `stop`, `start`
 
-### PUT /1/config
+Curl example:
+
+```
+curl -v --data "{\"method\":\"pause\",\"id\":1}" -H "Content-Type: application/json" -H "Authorization: Bearer SECRET" http://127.0.0.1:44444/json_rpc
+```
+
+### APIVersion 2
+
+#### GET /2/config
+
+Get current miner configuration. [Example](api/2/config.json).
+
+#### PUT /2/config
 
 Update current miner configuration. Common use case, get current configuration, make changes, and upload it to miner.
 
 Curl example:
 
 ```
-curl -v --data-binary @config.json -X PUT -H "Content-Type: application/json" -H "Authorization: Bearer SECRET" http://127.0.0.1:44444/1/config
+...GET current config...
+curl -v -H "Content-Type: application/json" -H "Authorization: Bearer SECRET" http://127.0.0.1:44444/2/config > config.json
+...make changes...
+vim config.json
+...PUT changed config...
+curl -v --data-binary @config.json -X PUT -H "Content-Type: application/json" -H "Authorization: Bearer SECRET" http://127.0.0.1:44444/2/config
 ```
+
+### APIVersion 1 (deprecated)
+
+#### GET /1/config
+
+Get current miner configuration. Currently identical to `GET /2/config`
+
+#### PUT /1/config
+
+Update current miner configuration. Currently identical to `PUT /2/config`

doc/api/2/backends.json

@@ -0,0 +1,78 @@
+[
+    {
+        "type": "cpu",
+        "enabled": true,
+        "algo": "rx/0",
+        "profile": "rx",
+        "hw-aes": true,
+        "priority": -1,
+        "msr": true,
+        "asm": "intel",
+        "argon2-impl": "AVX2",
+        "hugepages": [6, 6],
+        "memory": 6291456,
+        "hashrate": [1235.78, 1228.89, null],
+        "threads": [
+            {
+                "intensity": 1,
+                "affinity": 0,
+                "av": 1,
+                "hashrate": [409.75, 406.58, null]
+            },
+            {
+                "intensity": 1,
+                "affinity": 2,
+                "av": 1,
+                "hashrate": [412.9, 411.33, null]
+            },
+            {
+                "intensity": 1,
+                "affinity": 4,
+                "av": 1,
+                "hashrate": [413.11, 410.98, null]
+            }
+        ]
+    },
+    {
+        "type": "cuda",
+        "enabled": true,
+        "algo": "cn-heavy/xhv",
+        "profile": "cn-heavy/xhv",
+        "versions": {
+            "cuda-runtime": "11.6",
+            "cuda-driver": "11.6",
+            "plugin": "6.17.1-dev",
+            "nvml": "11.512.15",
+            "driver": "512.15"
+        },
+        "hashrate": [247.02, 247.34, null],
+        "threads": [
+            {
+                "index": 0,
+                "threads": 32,
+                "blocks": 38,
+                "bfactor": 6,
+                "bsleep": 25,
+                "affinity": -1,
+                "cclock": 0,
+                "mclock": 0,
+                "dataset_host": false,
+                "hashrate": [246.77, 247.26, null],
+                "name": "NVIDIA GeForce GTX 970",
+                "bus_id": "01:00.0",
+                "smx": 13,
+                "arch": 52,
+                "global_mem": 4294836224,
+                "clock": 1177,
+                "memory_clock": 3666,
+                "health": {
+                    "temperature": 69,
+                    "power": 161,
+                    "clock": 1328,
+                    "mem_clock": 3662,
+                    "fan_speed": [100]
+                }
+            }
+        ]
+    }
+]

doc/api/2/config.json

@@ -0,0 +1,136 @@
+{
+    "api": {
+        "id": null,
+        "worker-id": null
+    },
+    "http": {
+        "enabled": true,
+        "host": "127.0.0.1",
+        "port": 44444,
+        "access-token": "SECRET",
+        "restricted": false
+    },
+    "autosave": true,
+    "background": false,
+    "colors": true,
+    "title": true,
+    "randomx": {
+        "init": -1,
+        "init-avx2": -1,
+        "mode": "auto",
+        "1gb-pages": true,
+        "rdmsr": true,
+        "wrmsr": true,
+        "cache_qos": false,
+        "numa": true,
+        "scratchpad_prefetch_mode": 1
+    },
+    "cpu": {
+        "enabled": true,
+        "huge-pages": true,
+        "huge-pages-jit": true,
+        "hw-aes": null,
+        "priority": null,
+        "memory-pool": true,
+        "yield": true,
+        "asm": true,
+        "argon2-impl": null,
+        "argon2": [0, 2, 4, 6, 5, 7],
+        "astrobwt/v2": [1, 2, 3, 4, 5, 6, 7],
+        "cn": [
+            [1, 0],
+            [1, 2],
+            [1, 4]
+        ],
+        "cn-heavy": [
+            [1, 0],
+            [1, 2]
+        ],
+        "cn-lite": [
+            [1, 0],
+            [1, 2],
+            [1, 4],
+            [1, 6],
+            [1, 5],
+            [1, 7]
+        ],
+        "cn-pico": [
+            [2, 1],
+            [2, 2],
+            [2, 3],
+            [2, 4],
+            [2, 5],
+            [2, 6],
+            [2, 7]
+        ],
+        "cn/2": [
+            [1, 0],
+            [1, 2],
+            [1, 4]
+        ],
+        "cn/upx2": [
+            [2, 1],
+            [2, 2],
+            [2, 3],
+            [2, 4],
+            [2, 5],
+            [2, 6],
+            [2, 7]
+        ],
+        "ghostrider": [
+            [8, 0],
+            [8, 2],
+            [8, 4]
+        ],
+        "rx": [0, 2, 4],
+        "rx/arq": [1, 2, 3, 4, 5, 6, 7],
+        "rx/keva": [0, 2, 4, 6, 5, 7],
+        "rx/wow": [0, 2, 4, 6, 5, 7],
+        "cn-lite/0": false,
+        "cn/0": "cn"
+    },
+    "log-file": null,
+    "donate-level": 0,
+    "donate-over-proxy": 0,
+    "pools": [
+        {
+            "algo": null,
+            "coin": null,
+            "url": "some.pool:10064",
+            "user": "4blahblahblahblahblahblahblahblahblahblahblahblahblahblahblahblahblahblahblahblahblahblahblahbl",
+            "pass": "x",
+            "rig-id": null,
+            "nicehash": false,
+            "keepalive": true,
+            "enabled": true,
+            "tls": false,
+            "wss": false,
+            "daemon": false,
+            "socks5": null,
+            "self-select": null,
+            "submit-to-origin": false
+        }
+    ],
+    "retries": 5,
+    "retry-pause": 5,
+    "print-time": 64,
+    "syslog": false,
+    "tls": {
+        "enabled": false,
+        "protocols": null,
+        "cert": null,
+        "cert_key": null,
+        "ciphers": null,
+        "ciphersuites": null,
+        "dhparam": null
+    },
+    "dns": {
+        "ipv6": false,
+        "ttl": 30
+    },
+    "user-agent": null,
+    "verbose": 1,
+    "watch": true,
+    "pause-on-battery": false,
+    "pause-on-active": false
+}

doc/api/2/summary.json

@@ -0,0 +1,76 @@
+{
+    "id": "51aca77da137cb62",
+    "worker_id": "tpad",
+    "uptime": 106,
+    "restricted": false,
+    "resources": {
+        "memory": {
+            "free": 4977348608,
+            "total": 16659546112,
+            "resident_set_memory": 16441344
+        },
+        "load_average": [3.4, 2.7, 2.44],
+        "hardware_concurrency": 8
+    },
+    "features": ["api", "asm", "http", "hwloc", "tls"],
+    "results": {
+        "diff_current": 37638,
+        "shares_good": 3,
+        "shares_total": 3,
+        "avg_time": 35,
+        "avg_time_ms": 35603,
+        "hashes_total": 165638,
+        "best": [358821, 344438, 73371, 0, 0, 0, 0, 0, 0, 0]
+    },
+    "algo": "rx/0",
+    "connection": {
+        "pool": "some.pool:20064",
+        "ip": "127.1.2.3",
+        "uptime": 106,
+        "uptime_ms": 106811,
+        "ping": 405,
+        "failures": 0,
+        "tls": "TLSv1.3",
+        "tls-fingerprint": null,
+        "algo": "rx/0",
+        "diff": 37638,
+        "accepted": 3,
+        "rejected": 0,
+        "avg_time": 35,
+        "avg_time_ms": 35603,
+        "hashes_total": 165638
+    },
+    "version": "6.17.1-dev",
+    "kind": "miner",
+    "ua": "XMRig/6.17.1-dev (Linux x86_64) libuv/1.43.0 gcc/9.4.0",
+    "cpu": {
+        "brand": "Intel(R) Core(TM) i7-4700MQ CPU @ 2.40GHz",
+        "family": 6,
+        "model": 60,
+        "stepping": 3,
+        "proc_info": 198339,
+        "aes": true,
+        "avx2": true,
+        "x64": true,
+        "64_bit": true,
+        "l2": 1048576,
+        "l3": 6291456,
+        "cores": 4,
+        "threads": 8,
+        "packages": 1,
+        "nodes": 1,
+        "backend": "hwloc/2.7.0",
+        "msr": "intel",
+        "assembly": "intel",
+        "arch": "x86_64",
+        "flags": ["aes", "avx", "avx2", "bmi2", "osxsave", "pdpe1gb", "sse2", "ssse3", "sse4.1", "popcnt"]
+    },
+    "donate_level": 0,
+    "paused": false,
+    "algorithms": ["cn/0", "cn/1", "cn/2", "cn/r", "cn/fast", "cn/half", "cn/xao", "cn/rto", "cn/rwz", "cn/zls", "cn/double", "cn/ccx", "cn-lite/1", "cn-heavy/0", "cn-heavy/tube", "cn-heavy/xhv", "cn-pico", "cn-pico/tlo", "cn/upx2", "rx/0", "rx/wow", "rx/arq", "rx/graft", "rx/sfx", "rx/keva", "argon2/chukwa", "argon2/chukwav2", "argon2/ninja", "astrobwt/v2", "ghostrider"],
+    "hashrate": {
+        "total": [1207.19, 1210.82, null],
+        "highest": 1316.85
+    },
+    "hugepages": [6, 6]
+}

scripts/pool_mine_example.cmd

@@ -16,5 +16,5 @@
 :: Smaller pools also often have smaller fees/payout limits.
 
 cd /d "%~dp0"
-xmrig.exe -o pool.hashvault.pro:3333 -u 48edfHu7V9Z84YzzMa6fUueoELZ9ZRXq9VetWzYGzKt52XU5xvqgzYnDK9URnRoJMk1j8nLwEVsaSWJ4fhdUyZijBGUicoD -p x
+xmrig.exe -o xmrpool.eu:3333 -u 48edfHu7V9Z84YzzMa6fUueoELZ9ZRXq9VetWzYGzKt52XU5xvqgzYnDK9URnRoJMk1j8nLwEVsaSWJ4fhdUyZijBGUicoD -p x
 pause

scripts/solo_mine_example.cmd

@@ -12,5 +12,5 @@
 :: But you will only get a payout when you find a block which can take more than a year for a single low-end PC.
 
 cd /d "%~dp0"
-xmrig.exe -o node.xmr.to:18081 -a rx/0 -u 48edfHu7V9Z84YzzMa6fUueoELZ9ZRXq9VetWzYGzKt52XU5xvqgzYnDK9URnRoJMk1j8nLwEVsaSWJ4fhdUyZijBGUicoD --daemon
+xmrig.exe -o YOUR_NODE_IP:18081 -a rx/0 -u 48edfHu7V9Z84YzzMa6fUueoELZ9ZRXq9VetWzYGzKt52XU5xvqgzYnDK9URnRoJMk1j8nLwEVsaSWJ4fhdUyZijBGUicoD --daemon
 pause

src/backend/cpu/Cpu.h

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2020 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2018-2023 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2016-2023 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
@@ -37,7 +37,7 @@ public:
 };
 
 
-} /* namespace xmrig */
+} // namespace xmrig
 
 
-#endif /* XMRIG_CPU_H */
+#endif // XMRIG_CPU_H

src/backend/cpu/interfaces/ICpuInfo.h

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2018-2023 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <support@xmrig.com>
+ * Copyright (c) 2016-2023 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
@@ -26,6 +26,12 @@
 #include "crypto/common/Assembly.h"
 
 
+#ifdef XMRIG_FEATURE_HWLOC
+using hwloc_const_bitmap_t  = const struct hwloc_bitmap_s *;
+using hwloc_topology_t      = struct hwloc_topology *;
+#endif
+
+
 namespace xmrig {
 
 
@@ -116,10 +122,16 @@ public:
     virtual size_t threads() const                                                  = 0;
     virtual Vendor vendor() const                                                   = 0;
     virtual uint32_t model() const                                                  = 0;
+
+#   ifdef XMRIG_FEATURE_HWLOC
+    virtual bool membind(hwloc_const_bitmap_t nodeset)                              = 0;
+    virtual const std::vector<uint32_t> &nodeset() const                            = 0;
+    virtual hwloc_topology_t topology() const                                       = 0;
+#   endif
 };
 
 
-} /* namespace xmrig */
+} // namespace xmrig
 
 
 #endif // XMRIG_CPUINFO_H

src/backend/cpu/platform/BasicCpuInfo.cpp

@@ -296,7 +296,7 @@ xmrig::BasicCpuInfo::BasicCpuInfo() :
                 // Affected CPU models and stepping numbers are taken from https://www.intel.com/content/dam/support/us/en/documents/processors/mitigations-jump-conditional-code-erratum.pdf
                 m_jccErratum =
                     ((model == 0x4E) && (stepping == 0x3)) ||
-                    ((model == 0x55) && (stepping == 0x4)) ||
+                    ((model == 0x55) && ((stepping == 0x4) || (stepping == 0x7))) ||
                     ((model == 0x5E) && (stepping == 0x3)) ||
                     ((model == 0x8E) && (stepping >= 0x9) && (stepping <= 0xC)) ||
                     ((model == 0x9E) && (stepping >= 0x9) && (stepping <= 0xD)) ||

src/backend/cpu/platform/BasicCpuInfo.h

@@ -1,7 +1,7 @@
 /* XMRig
  * Copyright (c) 2017-2019 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2018-2023 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <support@xmrig.com>
+ * Copyright (c) 2016-2023 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
@@ -72,11 +72,10 @@ protected:
 #   endif
     }
 
-protected:
     Arch m_arch             = ARCH_UNKNOWN;
     bool m_jccErratum       = false;
     char m_brand[64 + 6]{};
-    size_t m_threads;
+    size_t m_threads        = 0;
     std::vector<int32_t> m_units;
     Vendor m_vendor         = VENDOR_UNKNOWN;
 
@@ -94,7 +93,7 @@ private:
 };
 
 
-} /* namespace xmrig */
+} // namespace xmrig
 
 
-#endif /* XMRIG_BASICCPUINFO_H */
+#endif // XMRIG_BASICCPUINFO_H

src/backend/cpu/platform/HwlocCpuInfo.cpp

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2018-2023 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <support@xmrig.com>
+ * Copyright (c) 2016-2023 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
@@ -36,27 +36,22 @@
 #include "base/io/log/Log.h"
 
 
-namespace xmrig {
+#if HWLOC_API_VERSION < 0x20000
-
+static inline int hwloc_obj_type_is_cache(hwloc_obj_type_t type)
-
-uint32_t HwlocCpuInfo::m_features = 0;
-
-
-static inline bool isCacheObject(hwloc_obj_t obj)
 {
-#   if HWLOC_API_VERSION >= 0x20000
+    return type == HWLOC_OBJ_CACHE;
-    return hwloc_obj_type_is_cache(obj->type);
-#   else
-    return obj->type == HWLOC_OBJ_CACHE;
-#   endif
 }
+#endif
+
+
+namespace xmrig {
 
 
 template <typename func>
 static inline void findCache(hwloc_obj_t obj, unsigned min, unsigned max, func lambda)
 {
     for (size_t i = 0; i < obj->arity; i++) {
-        if (isCacheObject(obj->children[i])) {
+        if (hwloc_obj_type_is_cache(obj->children[i]->type)) {
             const unsigned depth = obj->children[i]->attr->cache.depth;
             if (depth < min || depth > max) {
                 continue;
@@ -174,10 +169,6 @@ xmrig::HwlocCpuInfo::HwlocCpuInfo()
     m_packages  = countByType(m_topology, HWLOC_OBJ_PACKAGE);
 
     if (m_nodes > 1) {
-        if (hwloc_topology_get_support(m_topology)->membind->set_thisthread_membind) {
-            m_features |= SET_THISTHREAD_MEMBIND;
-        }
-
         m_nodeset.reserve(m_nodes);
         hwloc_obj_t node = nullptr;
 
@@ -298,8 +289,10 @@ void xmrig::HwlocCpuInfo::processTopLevelCache(hwloc_obj_t cache, const Algorith
     cores.reserve(m_cores);
     findByType(cache, HWLOC_OBJ_CORE, [&cores](hwloc_obj_t found) { cores.emplace_back(found); });
 
+    const bool L3_exclusive = isCacheExclusive(cache);
+
 #   ifdef XMRIG_ALGO_GHOSTRIDER
-    if ((algorithm == Algorithm::GHOSTRIDER_RTM) && (PUs > cores.size()) && (PUs < cores.size() * 2)) {
+    if ((algorithm == Algorithm::GHOSTRIDER_RTM) && L3_exclusive && (PUs > cores.size()) && (PUs < cores.size() * 2)) {
         // Don't use E-cores on Alder Lake
         cores.erase(std::remove_if(cores.begin(), cores.end(), [](hwloc_obj_t c) { return hwloc_bitmap_weight(c->cpuset) == 1; }), cores.end());
 
@@ -311,7 +304,6 @@ void xmrig::HwlocCpuInfo::processTopLevelCache(hwloc_obj_t cache, const Algorith
 #   endif
 
     size_t L3               = cache->attr->cache.size;
-    const bool L3_exclusive = isCacheExclusive(cache);
     size_t L2               = 0;
     int L2_associativity    = 0;
     size_t extra            = 0;
@@ -321,7 +313,7 @@ void xmrig::HwlocCpuInfo::processTopLevelCache(hwloc_obj_t cache, const Algorith
     if (cache->attr->cache.depth == 3) {
         for (size_t i = 0; i < cache->arity; ++i) {
             hwloc_obj_t l2 = cache->children[i];
-            if (!isCacheObject(l2) || l2->attr == nullptr) {
+            if (!hwloc_obj_type_is_cache(l2->type) || l2->attr == nullptr) {
                 continue;
             }
 
@@ -349,6 +341,10 @@ void xmrig::HwlocCpuInfo::processTopLevelCache(hwloc_obj_t cache, const Algorith
     }
 
 #   ifdef XMRIG_ALGO_RANDOMX
+    if ((algorithm.family() == Algorithm::RANDOM_X) && L3_exclusive && (PUs > cores.size()) && (PUs < cores.size() * 2)) {
+        // Use all L3+L2 on latest Intel CPUs with P-cores, E-cores and exclusive L3 cache
+        cacheHashes = (L3 + L2) / scratchpad;
+    }
     if (extra == 0 && algorithm.l2() > 0) {
         cacheHashes = std::min<size_t>(std::max<size_t>(L2 / algorithm.l2(), cores.size()), cacheHashes);
     }

src/backend/cpu/platform/HwlocCpuInfo.h

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2018-2023 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <support@xmrig.com>
+ * Copyright (c) 2016-2023 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
@@ -21,12 +21,9 @@
 
 
 #include "backend/cpu/platform/BasicCpuInfo.h"
-#include "base/tools/Object.h"
 
 
-using hwloc_const_bitmap_t  = const struct hwloc_bitmap_s *;
+using hwloc_obj_t = struct hwloc_obj *;
-using hwloc_obj_t           = struct hwloc_obj *;
-using hwloc_topology_t      = struct hwloc_topology *;
 
 
 namespace xmrig {
@@ -37,39 +34,27 @@ class HwlocCpuInfo : public BasicCpuInfo
 public:
     XMRIG_DISABLE_COPY_MOVE(HwlocCpuInfo)
 
-
-    enum Feature : uint32_t {
-        SET_THISTHREAD_MEMBIND = 1
-    };
-
-
     HwlocCpuInfo();
     ~HwlocCpuInfo() override;
 
-    static inline bool hasFeature(Feature feature)              { return m_features & feature; }
-
-    inline const std::vector<uint32_t> &nodeset() const         { return m_nodeset; }
-    inline hwloc_topology_t topology() const                    { return m_topology; }
-
-    bool membind(hwloc_const_bitmap_t nodeset);
-
 protected:
+    bool membind(hwloc_const_bitmap_t nodeset) override;
     CpuThreads threads(const Algorithm &algorithm, uint32_t limit) const override;
 
-    inline const char *backend() const override     { return m_backend; }
+    inline const char *backend() const override                     { return m_backend; }
-    inline size_t cores() const override            { return m_cores; }
+    inline const std::vector<uint32_t> &nodeset() const override    { return m_nodeset; }
-    inline size_t L2() const override               { return m_cache[2]; }
+    inline hwloc_topology_t topology() const override               { return m_topology; }
-    inline size_t L3() const override               { return m_cache[3]; }
+    inline size_t cores() const override                            { return m_cores; }
-    inline size_t nodes() const override            { return m_nodes; }
+    inline size_t L2() const override                               { return m_cache[2]; }
-    inline size_t packages() const override         { return m_packages; }
+    inline size_t L3() const override                               { return m_cache[3]; }
+    inline size_t nodes() const override                            { return m_nodes; }
+    inline size_t packages() const override                         { return m_packages; }
 
 private:
     CpuThreads allThreads(const Algorithm &algorithm, uint32_t limit) const;
     void processTopLevelCache(hwloc_obj_t cache, const Algorithm &algorithm, CpuThreads &threads, size_t limit) const;
     void setThreads(size_t threads);
 
-    static uint32_t m_features;
-
     char m_backend[20]          = { 0 };
     hwloc_topology_t m_topology = nullptr;
     size_t m_cache[5]           = { 0 };
@@ -80,7 +65,7 @@ private:
 };
 
 
-} /* namespace xmrig */
+} // namespace xmrig
 
 
-#endif /* XMRIG_HWLOCCPUINFO_H */
+#endif // XMRIG_HWLOCCPUINFO_H

src/backend/cpu/platform/lscpu_arm.cpp

@@ -1,7 +1,7 @@
 /* XMRig
  * Copyright (c) 2018      Riku Voipio <riku.voipio@iki.fi>
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2018-2023 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <support@xmrig.com>
+ * Copyright (c) 2016-2023 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,7 +17,6 @@
  *   along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include "base/tools/String.h"
 #include "3rdparty/fmt/core.h"
 
@@ -84,6 +83,7 @@ static const id_part arm_part[] = {
     { 0xc27, "Cortex-M7" },
     { 0xc60, "Cortex-M0+" },
     { 0xd01, "Cortex-A32" },
+    { 0xd02, "Cortex-A34" },
     { 0xd03, "Cortex-A53" },
     { 0xd04, "Cortex-A35" },
     { 0xd05, "Cortex-A55" },
@@ -97,40 +97,60 @@ static const id_part arm_part[] = {
     { 0xd0d, "Cortex-A77" },
     { 0xd0e, "Cortex-A76AE" },
     { 0xd13, "Cortex-R52" },
+    { 0xd15, "Cortex-R82" },
     { 0xd20, "Cortex-M23" },
     { 0xd21, "Cortex-M33" },
+    { 0xd40, "Neoverse-V1" },
     { 0xd41, "Cortex-A78" },
     { 0xd42, "Cortex-A78AE" },
+    { 0xd43, "Cortex-A65AE" },
+    { 0xd44, "Cortex-X1" },
+    { 0xd46, "Cortex-A510" },
+    { 0xd47, "Cortex-A710" },
+    { 0xd48, "Cortex-X2" },
+    { 0xd49, "Neoverse-N2" },
     { 0xd4a, "Neoverse-E1" },
     { 0xd4b, "Cortex-A78C" },
-    { -1, nullptr },
+    { 0xd4c, "Cortex-X1C" },
+    { 0xd4d, "Cortex-A715" },
+    { 0xd4e, "Cortex-X3" },
+    { 0xd4f, "Neoverse-V2" },
+    { -1, nullptr }
 };
 
 static const id_part brcm_part[] = {
-    { 0x0f, "Brahma B15" },
+    { 0x0f, "Brahma-B15" },
-    { 0x100, "Brahma B53" },
+    { 0x100, "Brahma-B53" },
     { 0x516, "ThunderX2" },
-    { -1, nullptr },
+    { -1, nullptr }
 };
 
 static const id_part dec_part[] = {
     { 0xa10, "SA110" },
     { 0xa11, "SA1100" },
-    { -1, nullptr },
+    { -1, nullptr }
 };
 
 static const id_part cavium_part[] = {
     { 0x0a0, "ThunderX" },
-    { 0x0a1, "ThunderX 88XX" },
+    { 0x0a1, "ThunderX-88XX" },
-    { 0x0a2, "ThunderX 81XX" },
+    { 0x0a2, "ThunderX-81XX" },
-    { 0x0a3, "ThunderX 83XX" },
+    { 0x0a3, "ThunderX-83XX" },
-    { 0x0af, "ThunderX2 99xx" },
+    { 0x0af, "ThunderX2-99xx" },
-    { -1, nullptr },
+    { 0x0b0, "OcteonTX2" },
+    { 0x0b1, "OcteonTX2-98XX" },
+    { 0x0b2, "OcteonTX2-96XX" },
+    { 0x0b3, "OcteonTX2-95XX" },
+    { 0x0b4, "OcteonTX2-95XXN" },
+    { 0x0b5, "OcteonTX2-95XXMM" },
+    { 0x0b6, "OcteonTX2-95XXO" },
+    { 0x0b8, "ThunderX3-T110" },
+    { -1, nullptr }
 };
 
 static const id_part apm_part[] = {
     { 0x000, "X-Gene" },
-    { -1, nullptr },
+    { -1, nullptr }
 };
 
 static const id_part qcom_part[] = {
@@ -141,36 +161,43 @@ static const id_part qcom_part[] = {
     { 0x201, "Kryo" },
     { 0x205, "Kryo" },
     { 0x211, "Kryo" },
-    { 0x800, "Falkor V1/Kryo" },
+    { 0x800, "Falkor-V1/Kryo" },
-    { 0x801, "Kryo V2" },
+    { 0x801, "Kryo-V2" },
+    { 0x802, "Kryo-3XX-Gold" },
+    { 0x803, "Kryo-3XX-Silver" },
+    { 0x804, "Kryo-4XX-Gold" },
+    { 0x805, "Kryo-4XX-Silver" },
     { 0xc00, "Falkor" },
     { 0xc01, "Saphira" },
-    { -1, nullptr },
+    { -1, nullptr }
 };
 
 static const id_part samsung_part[] = {
     { 0x001, "exynos-m1" },
-    { -1, nullptr },
+    { 0x002, "exynos-m3" },
+    { 0x003, "exynos-m4" },
+    { 0x004, "exynos-m5" },
+    { -1, nullptr }
 };
 
 static const id_part nvidia_part[] = {
     { 0x000, "Denver" },
     { 0x003, "Denver 2" },
     { 0x004, "Carmel" },
-    { -1, nullptr },
+    { -1, nullptr }
 };
 
 static const id_part marvell_part[] = {
-    { 0x131, "Feroceon 88FR131" },
+    { 0x131, "Feroceon-88FR131" },
     { 0x581, "PJ4/PJ4b" },
     { 0x584, "PJ4B-MP" },
-    { -1, nullptr },
+    { -1, nullptr }
 };
 
 static const id_part faraday_part[] = {
     { 0x526, "FA526" },
     { 0x626, "FA626" },
-    { -1, nullptr },
+    { -1, nullptr }
 };
 
 static const id_part intel_part[] = {
@@ -195,23 +222,50 @@ static const id_part intel_part[] = {
     { 0x689, "PXA31x" },
     { 0xb11, "SA1110" },
     { 0xc12, "IPX1200" },
-    { -1, nullptr },
+    { -1, nullptr }
 };
 
 static const struct id_part fujitsu_part[] = {
     { 0x001, "A64FX" },
-    { -1, "unknown" },
+    { -1, nullptr }
 };
 
 static const id_part hisi_part[] = {
-    { 0xd01, "Kunpeng-920" }, /* aka tsv110 */
+    { 0xd01, "Kunpeng-920" },	/* aka tsv110 */
-    { -1, nullptr },
+    { 0xd40, "Cortex-A76" },	/* HiSilicon uses this ID though advertises A76 */
+    { -1, nullptr }
 };
 
 static const id_part apple_part[] = {
     { 0x022, "M1" },
     { 0x023, "M1" },
-    { -1, nullptr },
+    { 0x024, "M1-Pro" },
+    { 0x025, "M1-Pro" },
+    { 0x028, "M1-Max" },
+    { 0x029, "M1-Max" },
+    { 0x032, "M2" },
+    { 0x033, "M2" },
+    { 0x034, "M2-Pro" },
+    { 0x035, "M2-Pro" },
+    { 0x038, "M2-Max" },
+    { 0x039, "M2-Max" },
+    { -1, nullptr }
+};
+
+
+static const struct id_part ft_part[] = {
+    { 0x660, "FTC660" },
+    { 0x661, "FTC661" },
+    { 0x662, "FTC662" },
+    { 0x663, "FTC663" },
+    { -1, nullptr }
+};
+
+
+static const struct id_part ampere_part[] = {
+    { 0xac3, "Ampere-1" },
+    { 0xac4, "Ampere-1a" },
+    { -1, nullptr }
 };
 
 
@@ -229,7 +283,9 @@ static const hw_impl hw_implementer[] = {
     { 0x56, marvell_part, "Marvell" },
     { 0x61, apple_part,   "Apple" },
     { 0x66, faraday_part, "Faraday" },
-    { 0x69, intel_part,   "Intel" }
+    { 0x69, intel_part,   "Intel" },
+    { 0x70, ft_part,      "Phytium" },
+    { 0xc0, ampere_part,  "Ampere" }
 };
 
 

src/backend/cuda/wrappers/CudaLib.cpp

@@ -353,13 +353,9 @@ bool xmrig::CudaLib::open()
 #   ifdef XMRIG_OS_LINUX
     if (m_loader == defaultLoader) {
         m_loader = Process::location(Process::ExeLocation, m_loader);
-    }
+        if (uv_dlopen(m_loader, &cudaLib) == 0) {
-    else {
+            return true;
-        return false;
+        }
-    }
-
-    if (uv_dlopen(m_loader, &cudaLib) == 0) {
-        return true;
     }
 #   endif
 

src/backend/opencl/runners/tools/OclKawPow.cpp

@@ -399,6 +399,9 @@ private:
     uv_loop_t* m_loop          = nullptr;
     uv_thread_t m_loopThread   = {};
     uv_async_t m_shutdownAsync = {};
+    uv_async_t m_batonAsync    = {};
+
+    std::vector<KawPowBaton> m_batons;
 
     static void loop(void* data)
     {
@@ -419,19 +422,37 @@ void KawPowBuilder::build_async(const IOclRunner& runner, uint64_t period, uint3
     if (!m_loop) {
         m_loop = new uv_loop_t{};
         uv_loop_init(m_loop);
-        uv_async_init(m_loop, &m_shutdownAsync, [](uv_async_t* handle) { uv_close(reinterpret_cast<uv_handle_t*>(handle), nullptr); });
+
+        uv_async_init(m_loop, &m_shutdownAsync, [](uv_async_t* handle)
+            {
+                KawPowBuilder* builder = reinterpret_cast<KawPowBuilder*>(handle->data);
+                uv_close(reinterpret_cast<uv_handle_t*>(&builder->m_shutdownAsync), nullptr);
+                uv_close(reinterpret_cast<uv_handle_t*>(&builder->m_batonAsync), nullptr);
+            });
+
+        uv_async_init(m_loop, &m_batonAsync, [](uv_async_t* handle)
+            {
+                std::vector<KawPowBaton> batons;
+                {
+                    KawPowBuilder* b = reinterpret_cast<KawPowBuilder*>(handle->data);
+
+                    std::lock_guard<std::mutex> lock(b->m_mutex);
+                    batons = std::move(b->m_batons);
+                }
+
+                for (const KawPowBaton& baton : batons) {
+                    builder.build(baton.runner, baton.period, baton.worksize);
+                }
+            });
+
+        m_shutdownAsync.data = this;
+        m_batonAsync.data = this;
+
         uv_thread_create(&m_loopThread, loop, this);
     }
 
-    KawPowBaton* baton = new KawPowBaton(runner, period, worksize);
+    m_batons.emplace_back(runner, period, worksize);
-
+    uv_async_send(&m_batonAsync);
-    uv_queue_work(m_loop, &baton->req,
-        [](uv_work_t* req) {
-            KawPowBaton* baton = static_cast<KawPowBaton*>(req->data);
-            builder.build(baton->runner, baton->period, baton->worksize);
-        },
-        [](uv_work_t* req, int) { delete static_cast<KawPowBaton*>(req->data); }
-    );
 }
 
 

src/base/api/Api.cpp

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2018-2023 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2016-2023 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
@@ -123,6 +123,21 @@ void xmrig::Api::stop()
 }
 
 
+void xmrig::Api::tick()
+{
+#   ifdef XMRIG_FEATURE_HTTP
+    if (m_httpd->isBound() || !m_base->config()->http().isEnabled()) {
+        return;
+    }
+
+    if (++m_ticks % 10 == 0) {
+        m_ticks = 0;
+        m_httpd->start();
+    }
+#   endif
+}
+
+
 void xmrig::Api::onConfigChanged(Config *config, Config *previousConfig)
 {
     if (config->apiId() != previousConfig->apiId()) {

src/base/api/Api.h

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2018-2023 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2016-2023 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
@@ -21,7 +21,6 @@
 
 
 #include <vector>
-#include <cstdint>
 
 
 #include "base/kernel/interfaces/IBaseListener.h"
@@ -44,7 +43,7 @@ class Api : public IBaseListener
 public:
     XMRIG_DISABLE_COPY_MOVE_DEFAULT(Api)
 
-    Api(Base *base);
+    explicit Api(Base *base);
     ~Api() override;
 
     inline const char *id() const                   { return m_id; }
@@ -54,6 +53,7 @@ public:
     void request(const HttpData &req);
     void start();
     void stop();
+    void tick();
 
 protected:
     void onConfigChanged(Config *config, Config *previousConfig) override;
@@ -65,14 +65,15 @@ private:
 
     Base *m_base;
     char m_id[32]{};
-    String m_workerId;
     const uint64_t m_timestamp;
-    Httpd *m_httpd = nullptr;
+    Httpd *m_httpd  = nullptr;
     std::vector<IApiListener *> m_listeners;
+    String m_workerId;
+    uint8_t m_ticks = 0;
 };
 
 
 } // namespace xmrig
 
 
-#endif /* XMRIG_API_H */
+#endif // XMRIG_API_H

src/base/api/Httpd.h

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2018-2023 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2016-2023 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,11 +22,6 @@
 
 #include "base/kernel/interfaces/IBaseListener.h"
 #include "base/net/http/HttpListener.h"
-#include "base/tools/Object.h"
-
-
-#include <cstdint>
-#include <memory>
 
 
 namespace xmrig {
@@ -43,9 +38,11 @@ class Httpd : public IBaseListener, public IHttpListener
 public:
     XMRIG_DISABLE_COPY_MOVE_DEFAULT(Httpd)
 
-    Httpd(Base *base);
+    explicit Httpd(Base *base);
     ~Httpd() override;
 
+    inline bool isBound() const { return m_server != nullptr; }
+
     bool start();
     void stop();
 
@@ -69,7 +66,7 @@ private:
 };
 
 
-} /* namespace xmrig */
+} // namespace xmrig
 
 
-#endif /* XMRIG_HTTPD_H */
+#endif // XMRIG_HTTPD_H

src/base/api/interfaces/IApiRequest.h

@@ -52,6 +52,8 @@ public:
     enum RequestType {
         REQ_UNKNOWN,
         REQ_SUMMARY,
+        REQ_BACKENDS,
+        REQ_CONFIG,
         REQ_JSON_RPC
     };
 

src/base/api/requests/ApiRequest.h

@@ -60,7 +60,7 @@ protected:
     inline Source source() const override           { return m_source; }
     inline void done(int) override                  { m_state = STATE_DONE; }
 
-    int m_version       = 1;
+    int m_version       = 0;
     RequestType m_type  = REQ_UNKNOWN;
     State m_state       = STATE_NEW;
     String m_rpcMethod;

src/base/api/requests/HttpApiRequest.cpp

@@ -67,10 +67,33 @@ xmrig::HttpApiRequest::HttpApiRequest(const HttpData &req, bool restricted) :
     m_res(req.id()),
     m_url(req.url.c_str())
 {
-    if (method() == METHOD_GET) {
+    if (url().size() > 4 && memcmp(url().data(), "/", 1) == 0 && memcmp(url().data()+2, "/", 1) == 0) {
-        if (url() == "/1/summary" || url() == "/2/summary" || url() == "/api.json") {
+        if (memcmp(url().data(), "/2/", 3) == 0) {
-            m_type = REQ_SUMMARY;
+            m_version = 2;
+        } else if (memcmp(url().data(), "/1/", 3) == 0) {
+            m_version = 1;
         }
+        switch (url().size()) {
+        case 9:
+            if (memcmp(url().data()+3, "config", 6) == 0) {
+                m_type = REQ_CONFIG;
+            }
+            break;
+        case 10:
+            if (memcmp(url().data()+3, "summary", 7) == 0) {
+                m_type = REQ_SUMMARY;
+            }
+            break;
+        case 11:
+            if (memcmp(url().data()+3, "backends", 8) == 0) {
+                m_type = REQ_BACKENDS;
+            }
+            break;
+        }
+    }
+
+    if (url() == "/api.json") {
+            m_type = REQ_SUMMARY;
     }
 
     if (method() == METHOD_POST && url() == "/json_rpc") {
@@ -94,12 +117,6 @@ xmrig::HttpApiRequest::HttpApiRequest(const HttpData &req, bool restricted) :
 
         return;
     }
-
-    if (url().size() > 4) {
-        if (memcmp(url().data(), "/2/", 3) == 0) {
-            m_version = 2;
-        }
-    }
 }
 
 

src/base/crypto/Coin.cpp

@@ -53,6 +53,7 @@ static const CoinInfo coinInfo[] = {
     { Algorithm::RX_KEVA,         "KVA",      "Kevacoin",     0,      0,              MAGENTA_BG_BOLD(WHITE_BOLD_S " keva    ") },
     { Algorithm::KAWPOW_RVN,      "RVN",      "Ravencoin",    0,      0,              BLUE_BG_BOLD(   WHITE_BOLD_S " raven   ") },
     { Algorithm::RX_WOW,          "WOW",      "Wownero",      300,    100000000000,   MAGENTA_BG_BOLD(WHITE_BOLD_S " wownero ") },
+    { Algorithm::RX_0,            "ZEPH",     "Zephyr",       120,    1000000000000,  BLUE_BG_BOLD(   WHITE_BOLD_S " zephyr  ") },
 };
 
 

src/base/crypto/Coin.h

@@ -39,6 +39,7 @@ public:
         KEVA,
         RAVEN,
         WOWNERO,
+        ZEPHYR,
         MAX
     };
 

src/base/kernel/Base.cpp

@@ -45,13 +45,6 @@
 #ifdef XMRIG_FEATURE_API
 #   include "base/api/Api.h"
 #   include "base/api/interfaces/IApiRequest.h"
-
-namespace xmrig {
-
-static const char *kConfigPathV1 = "/1/config";
-static const char *kConfigPathV2 = "/2/config";
-
-} // namespace xmrig
 #endif
 
 
@@ -317,7 +310,7 @@ void xmrig::Base::onFileChanged(const String &fileName)
 void xmrig::Base::onRequest(IApiRequest &request)
 {
     if (request.method() == IApiRequest::METHOD_GET) {
-        if (request.url() == kConfigPathV1 || request.url() == kConfigPathV2) {
+        if (request.type() == IApiRequest::REQ_CONFIG) {
             if (request.isRestricted()) {
                 return request.done(403);
             }
@@ -327,7 +320,7 @@ void xmrig::Base::onRequest(IApiRequest &request)
         }
     }
     else if (request.method() == IApiRequest::METHOD_PUT || request.method() == IApiRequest::METHOD_POST) {
-        if (request.url() == kConfigPathV1 || request.url() == kConfigPathV2) {
+        if (request.type() == IApiRequest::REQ_CONFIG) {
             request.accept();
 
             if (!reload(request.json())) {

src/base/kernel/Platform.h

@@ -49,6 +49,8 @@ public:
     static inline bool isUserActive(uint64_t ms)    { return idleTime() < ms; }
     static inline const String &userAgent()         { return m_userAgent; }
 
+    static bool hasKeepalive();
+
     static bool isOnBatteryPower();
     static uint64_t idleTime();
 

src/base/kernel/Platform_hwloc.cpp

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2020 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2018-2023 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2016-2023 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
@@ -16,9 +16,7 @@
  *   along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include "base/kernel/Platform.h"
-#include "backend/cpu/platform/HwlocCpuInfo.h"
 #include "backend/cpu/Cpu.h"
 
 
@@ -29,20 +27,21 @@
 #ifndef XMRIG_OS_APPLE
 bool xmrig::Platform::setThreadAffinity(uint64_t cpu_id)
 {
-    auto cpu       = static_cast<HwlocCpuInfo *>(Cpu::info());
+    auto topology = Cpu::info()->topology();
-    hwloc_obj_t pu = hwloc_get_pu_obj_by_os_index(cpu->topology(), static_cast<unsigned>(cpu_id));
+    auto pu       = hwloc_get_pu_obj_by_os_index(topology, static_cast<unsigned>(cpu_id));
 
     if (pu == nullptr) {
         return false;
     }
 
-    if (hwloc_set_cpubind(cpu->topology(), pu->cpuset, HWLOC_CPUBIND_THREAD | HWLOC_CPUBIND_STRICT) >= 0) {
+    if (hwloc_set_cpubind(topology, pu->cpuset, HWLOC_CPUBIND_THREAD | HWLOC_CPUBIND_STRICT) >= 0) {
         std::this_thread::sleep_for(std::chrono::milliseconds(1));
         return true;
     }
 
-    const bool result = (hwloc_set_cpubind(cpu->topology(), pu->cpuset, HWLOC_CPUBIND_THREAD) >= 0);
+    const bool result = (hwloc_set_cpubind(topology, pu->cpuset, HWLOC_CPUBIND_THREAD) >= 0);
     std::this_thread::sleep_for(std::chrono::milliseconds(1));
+
     return result;
 }
 #endif

src/base/kernel/Platform_mac.cpp

@@ -55,6 +55,12 @@ char *xmrig::Platform::createUserAgent()
 }
 
 
+bool xmrig::Platform::hasKeepalive()
+{
+    return true;
+}
+
+
 bool xmrig::Platform::setThreadAffinity(uint64_t cpu_id)
 {
     return true;

src/base/kernel/Platform_unix.cpp

@@ -70,6 +70,12 @@ char *xmrig::Platform::createUserAgent()
 }
 
 
+bool xmrig::Platform::hasKeepalive()
+{
+    return true;
+}
+
+
 #ifndef XMRIG_FEATURE_HWLOC
 #ifdef __DragonFly__
 

src/base/kernel/Platform_win.cpp

@@ -70,6 +70,12 @@ char *xmrig::Platform::createUserAgent()
 }
 
 
+bool xmrig::Platform::hasKeepalive()
+{
+    return winOsVersion().dwMajorVersion >= 6;
+}
+
+
 #ifndef XMRIG_FEATURE_HWLOC
 bool xmrig::Platform::setThreadAffinity(uint64_t cpu_id)
 {

src/base/net/stratum/Client.cpp

@@ -50,6 +50,7 @@
 #include "base/tools/Cvt.h"
 #include "base/tools/cryptonote/BlobReader.h"
 #include "net/JobResult.h"
+#include "base/kernel/Platform.h"
 
 
 #ifdef _MSC_VER
@@ -567,9 +568,9 @@ void xmrig::Client::connect(const sockaddr *addr)
     uv_tcp_init(uv_default_loop(), m_socket);
     uv_tcp_nodelay(m_socket, 1);
 
-#   ifndef WIN32
+    if (Platform::hasKeepalive()) {
-    uv_tcp_keepalive(m_socket, 1, 60);
+        uv_tcp_keepalive(m_socket, 1, 60);
-#   endif
+    }
 
     uv_tcp_connect(req, m_socket, addr, onConnect);
 }

src/base/net/stratum/DaemonClient.cpp

@@ -46,6 +46,7 @@
 #include "base/tools/Timer.h"
 #include "base/tools/cryptonote/Signatures.h"
 #include "net/JobResult.h"
+#include "base/kernel/Platform.h"
 
 
 #ifdef XMRIG_FEATURE_TLS
@@ -358,9 +359,9 @@ void xmrig::DaemonClient::onResolved(const DnsRecords &records, int status, cons
     uv_tcp_init(uv_default_loop(), s);
     uv_tcp_nodelay(s, 1);
 
-#   ifndef WIN32
+    if (Platform::hasKeepalive()) {
-    uv_tcp_keepalive(s, 1, 60);
+        uv_tcp_keepalive(s, 1, 60);
-#   endif
+    }
 
     if (m_pool.zmq_port() > 0) {
         delete m_ZMQSocket;

src/base/tools/cryptonote/BlockTemplate.cpp

@@ -197,6 +197,11 @@ bool xmrig::BlockTemplate::parse(bool hashes)
         ar(m_vote);
     }
 
+    if (m_coin == Coin::ZEPHYR) {
+        uint8_t pricing_record[24];
+        ar(pricing_record);
+    }
+
     // Miner transaction begin
     // Prefix begin
     setOffset(MINER_TX_PREFIX_OFFSET, ar.index());
@@ -220,8 +225,8 @@ bool xmrig::BlockTemplate::parse(bool hashes)
     ar(m_height);
     ar(m_numOutputs);
 
-    // must be 1 output
+    const uint64_t expected_outputs = (m_coin == Coin::ZEPHYR) ? 2 : 1;
-    if (m_numOutputs != 1) {
+    if (m_numOutputs != expected_outputs) {
         return false;
     }
 
@@ -237,7 +242,35 @@ bool xmrig::BlockTemplate::parse(bool hashes)
 
     ar(m_ephPublicKey, kKeySize);
 
-    if (m_outputType == 3) {
+    if (m_coin == Coin::ZEPHYR) {
+        if (m_outputType != 2) {
+            return false;
+        }
+
+        uint64_t asset_type_len;
+        ar(asset_type_len);
+        ar.skip(asset_type_len);
+        ar(m_viewTag);
+
+        uint64_t amount2;
+        ar(amount2);
+
+        uint8_t output_type2;
+        ar(output_type2);
+        if (output_type2 != 2) {
+            return false;
+        }
+
+        Span key2;
+        ar(key2, kKeySize);
+
+        ar(asset_type_len);
+        ar.skip(asset_type_len);
+
+        uint8_t view_tag2;
+        ar(view_tag2);
+    }
+    else if (m_outputType == 3) {
         ar(m_viewTag);
     }
 
@@ -248,6 +281,8 @@ bool xmrig::BlockTemplate::parse(bool hashes)
     BlobReader<true> ar_extra(blob(TX_EXTRA_OFFSET), m_extraSize);
     ar.skip(m_extraSize);
 
+    bool pubkey_offset_first = true;
+
     while (ar_extra.index() < m_extraSize) {
         uint64_t extra_tag  = 0;
         uint64_t size       = 0;
@@ -256,7 +291,10 @@ bool xmrig::BlockTemplate::parse(bool hashes)
 
         switch (extra_tag) {
         case 0x01: // TX_EXTRA_TAG_PUBKEY
-            setOffset(TX_PUBKEY_OFFSET, offset(TX_EXTRA_OFFSET) + ar_extra.index());
+            if (pubkey_offset_first) {
+                pubkey_offset_first = false;
+                setOffset(TX_PUBKEY_OFFSET, offset(TX_EXTRA_OFFSET) + ar_extra.index());
+            }
             ar_extra.skip(kKeySize);
             break;
 
@@ -277,6 +315,13 @@ bool xmrig::BlockTemplate::parse(bool hashes)
         }
     }
 
+    if (m_coin == Coin::ZEPHYR) {
+        uint64_t pricing_record_height, amount_burnt, amount_minted;
+        ar(pricing_record_height);
+        ar(amount_burnt);
+        ar(amount_minted);
+    }
+
     setOffset(MINER_TX_PREFIX_END_OFFSET, ar.index());
     // Prefix end
 

src/core/Miner.cpp

@@ -689,7 +689,7 @@ void xmrig::Miner::onRequest(IApiRequest &request)
             d_ptr->getMiner(request.reply(), request.doc(), request.version());
             d_ptr->getHashrate(request.reply(), request.doc(), request.version());
         }
-        else if (request.url() == "/2/backends") {
+        else if (request.type() == IApiRequest::REQ_BACKENDS && request.version() == 2) {
             request.accept();
 
             d_ptr->getBackends(request.reply(), request.doc());
@@ -711,6 +711,12 @@ void xmrig::Miner::onRequest(IApiRequest &request)
 
             stop();
         }
+        else if (request.rpcMethod() == "start") {
+            request.accept();
+
+            const auto config = d_ptr->controller->config();
+            onConfigChanged(config, config);
+        }
     }
 
     for (IBackend *backend : d_ptr->backends) {

src/crypto/common/VirtualMemory_hwloc.cpp

@@ -1,8 +1,8 @@
 /* XMRig
  * Copyright (c) 2018      Lee Clagett <https://github.com/vtnerd>
  * Copyright (c) 2018-2019 tevador     <tevador@gmail.com>
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2018-2023 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2016-2023 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
@@ -18,10 +18,8 @@
  *   along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include "crypto/common/VirtualMemory.h"
 #include "backend/cpu/Cpu.h"
-#include "backend/cpu/platform/HwlocCpuInfo.h"
 #include "base/io/log/Log.h"
 
 
@@ -34,10 +32,9 @@ uint32_t xmrig::VirtualMemory::bindToNUMANode(int64_t affinity)
         return 0;
     }
 
-    auto cpu       = static_cast<HwlocCpuInfo *>(Cpu::info());
+    auto pu = hwloc_get_pu_obj_by_os_index(Cpu::info()->topology(), static_cast<unsigned>(affinity));
-    hwloc_obj_t pu = hwloc_get_pu_obj_by_os_index(cpu->topology(), static_cast<unsigned>(affinity));
 
-    if (pu == nullptr || !cpu->membind(pu->nodeset)) {
+    if (pu == nullptr || !Cpu::info()->membind(pu->nodeset)) {
         LOG_WARN("CPU #%02" PRId64 " warning: \"can't bind memory\"", affinity);
 
         return 0;

src/crypto/ghostrider/ghostrider.cpp

@@ -47,9 +47,12 @@
 #include <uv.h>
 
 #ifdef XMRIG_FEATURE_HWLOC
-#include "base/kernel/Platform.h"
+#   include "base/kernel/Platform.h"
-#include "backend/cpu/platform/HwlocCpuInfo.h"
+#   include <hwloc.h>
-#include <hwloc.h>
+
+#   if HWLOC_API_VERSION < 0x20000
+#       define HWLOC_OBJ_L3CACHE HWLOC_OBJ_CACHE
+#   endif
 #endif
 
 #if defined(XMRIG_ARM)
@@ -86,7 +89,7 @@ CORE_HASH(14, whirlpool  );
 
 #undef CORE_HASH
 
-typedef void (*core_hash_func)(const uint8_t* data, size_t size, uint8_t* output);
+using core_hash_func = void (*)(const uint8_t* data, size_t size, uint8_t* output);
 static const core_hash_func core_hash[15] = { h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11, h12, h13, h14 };
 
 namespace xmrig
@@ -165,6 +168,8 @@ static struct AlgoTune
 
 struct HelperThread
 {
+    XMRIG_DISABLE_COPY_MOVE_DEFAULT(HelperThread)
+
     HelperThread(hwloc_bitmap_t cpu_set, int priority, bool is8MB) : m_cpuSet(cpu_set), m_priority(priority), m_is8MB(is8MB)
     {
         uv_mutex_init(&m_mutex);
@@ -194,14 +199,17 @@ struct HelperThread
 
     struct TaskBase
     {
-        virtual ~TaskBase() {}
+        XMRIG_DISABLE_COPY_MOVE(TaskBase)
-        virtual void run() = 0;
+
+        TaskBase()          = default;
+        virtual ~TaskBase() = default;
+        virtual void run()  = 0;
     };
 
     template<typename T>
     struct Task : TaskBase
     {
-        inline Task(T&& task) : m_task(std::move(task))
+        explicit inline Task(T&& task) : m_task(std::move(task))
         {
             static_assert(sizeof(Task) <= 128, "Task struct is too large");
         }
@@ -219,7 +227,7 @@ struct HelperThread
     inline void launch_task(T&& task)
     {
         uv_mutex_lock(&m_mutex);
-        new (&m_tasks[m_numTasks++]) Task<T>(std::move(task));
+        new (&m_tasks[m_numTasks++]) Task<T>(std::forward<T>(task));
         uv_cond_signal(&m_cond);
         uv_mutex_unlock(&m_mutex);
     }
@@ -234,7 +242,7 @@ struct HelperThread
     void run()
     {
         if (hwloc_bitmap_weight(m_cpuSet) > 0) {
-            hwloc_topology_t topology = reinterpret_cast<HwlocCpuInfo*>(Cpu::info())->topology();
+            hwloc_topology_t topology = Cpu::info()->topology();
             if (hwloc_set_cpubind(topology, m_cpuSet, HWLOC_CPUBIND_THREAD | HWLOC_CPUBIND_STRICT) < 0) {
                 hwloc_set_cpubind(topology, m_cpuSet, HWLOC_CPUBIND_THREAD);
             }
@@ -288,9 +296,9 @@ void benchmark()
         // Try to avoid CPU core 0 because many system threads use it and can interfere
         uint32_t thread_index1 = (Cpu::info()->threads() > 2) ? 2 : 0;
 
-        hwloc_topology_t topology = reinterpret_cast<HwlocCpuInfo*>(Cpu::info())->topology();
+        hwloc_topology_t topology = Cpu::info()->topology();
         hwloc_obj_t pu = hwloc_get_pu_obj_by_os_index(topology, thread_index1);
-        hwloc_obj_t pu2;
+        hwloc_obj_t pu2 = nullptr;
         hwloc_get_closest_objs(topology, pu, &pu2, 1);
         uint32_t thread_index2 = pu2 ? pu2->os_index : thread_index1;
 
@@ -481,12 +489,17 @@ HelperThread* create_helper_thread(int64_t cpu_index, int priority, const std::v
     }
 
     if (cpu_index >= 0) {
-        hwloc_topology_t topology = reinterpret_cast<HwlocCpuInfo*>(Cpu::info())->topology();
+        hwloc_obj_t root = hwloc_get_root_obj(Cpu::info()->topology());
-        hwloc_obj_t root = hwloc_get_root_obj(topology);
 
         bool is8MB = false;
 
         findByType(root, HWLOC_OBJ_L3CACHE, [cpu_index, &is8MB](hwloc_obj_t obj) {
+#           if HWLOC_API_VERSION < 0x20000
+            if (obj->attr->cache.depth != 3) {
+                return false;
+            }
+#           endif
+
             if (!hwloc_bitmap_isset(obj->cpuset, cpu_index)) {
                 return false;
             }
@@ -510,7 +523,11 @@ HelperThread* create_helper_thread(int64_t cpu_index, int priority, const std::v
             return true;
         });
 
+#       if HWLOC_API_VERSION >= 0x20000
         for (auto obj_type : { HWLOC_OBJ_CORE, HWLOC_OBJ_L1CACHE, HWLOC_OBJ_L2CACHE, HWLOC_OBJ_L3CACHE }) {
+#       else
+        for (auto obj_type : { HWLOC_OBJ_CORE, HWLOC_OBJ_CACHE }) {
+#       endif
             findByType(root, obj_type, [cpu_index, helper_cpu_set, main_threads_set](hwloc_obj_t obj) {
                 const hwloc_cpuset_t& s = obj->cpuset;
                 if (hwloc_bitmap_isset(s, cpu_index)) {
@@ -571,9 +588,13 @@ void hash_octa(const uint8_t* data, size_t size, uint8_t* output, cryptonight_ct
     uint8_t tmp[64 * N];
 
     if (helper && (tune[cn_indices[0]].threads == 2) && (tune[cn_indices[1]].threads == 2) && (tune[cn_indices[2]].threads == 2)) {
-        const size_t n = N / 2;
+        constexpr size_t n = N / 2;
+
+        helper->launch_task([av, data, size, &ctx_memory, ctx, &cn_indices, &core_indices, &tmp, output, tune]() {
+#           ifdef _MSC_VER
+            constexpr size_t n = N / 2;
+#           endif
 
-        helper->launch_task([n, av, data, size, &ctx_memory, ctx, &cn_indices, &core_indices, &tmp, output, tune]() {
             const uint8_t* input = data;
             size_t input_size = size;
 

src/crypto/kawpow/KPHash.h

@@ -7,8 +7,8 @@
  * Copyright 2017-2019 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
  * Copyright 2018      Lee Clagett <https://github.com/vtnerd>
  * Copyright 2018-2019 tevador     <tevador@gmail.com>
- * Copyright 2018-2020 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2018-2023 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright 2016-2023 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
@@ -28,7 +28,7 @@
 #define XMRIG_KP_HASH_H
 
 
-#include <stdint.h>
+#include <cstdint>
 
 
 namespace xmrig
@@ -43,16 +43,16 @@ class KPHash
 public:
     static constexpr uint32_t EPOCH_LENGTH  = 7500;
     static constexpr uint32_t PERIOD_LENGTH = 3;
-    static constexpr int CNT_CACHE = 11;
+    static constexpr int CNT_CACHE          = 11;
-    static constexpr int CNT_MATH = 18;
+    static constexpr int CNT_MATH           = 18;
-    static constexpr uint32_t REGS = 32;
+    static constexpr uint32_t REGS          = 32;
-    static constexpr uint32_t LANES = 16;
+    static constexpr uint32_t LANES         = 16;
 
     static void calculate(const KPCache& light_cache, uint32_t block_height, const uint8_t (&header_hash)[32], uint64_t nonce, uint32_t (&output)[8], uint32_t (&mix_hash)[8]);
 };
 
 
-} /* namespace xmrig */
+} // namespace xmrig
 
 
-#endif /* XMRIG_KP_HASH_H */
+#endif // XMRIG_KP_HASH_H

src/crypto/randomx/aes_hash.cpp

@@ -34,6 +34,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "base/tools/Chrono.h"
 #include "crypto/randomx/randomx.h"
 #include "crypto/randomx/soft_aes.h"
+#include "crypto/randomx/instruction.hpp"
+#include "crypto/randomx/common.hpp"
 #include "crypto/rx/Profiler.h"
 
 #define AES_HASH_1R_STATE0 0xd7983aad, 0xcc82db47, 0x9fa856de, 0x92b52c0d
@@ -165,6 +167,9 @@ void fillAes1Rx4(void *state, size_t outputSize, void *buffer) {
 template void fillAes1Rx4<true>(void *state, size_t outputSize, void *buffer);
 template void fillAes1Rx4<false>(void *state, size_t outputSize, void *buffer);
 
+static constexpr randomx::Instruction inst{ 0xFF, 7, 7, 0xFF, 0xFFFFFFFFU };
+alignas(16) static const randomx::Instruction inst_mask[2] = { inst, inst };
+
 template<int softAes>
 void fillAes4Rx4(void *state, size_t outputSize, void *buffer) {
 	const uint8_t* outptr = (uint8_t*)buffer;
@@ -187,32 +192,42 @@ void fillAes4Rx4(void *state, size_t outputSize, void *buffer) {
 	state2 = rx_load_vec_i128((rx_vec_i128*)state + 2);
 	state3 = rx_load_vec_i128((rx_vec_i128*)state + 3);
 
-	while (outptr < outputEnd) {
+#define TRANSFORM do { \
-		state0 = aesdec<softAes>(state0, key0);
+	state0 = aesdec<softAes>(state0, key0); \
-		state1 = aesenc<softAes>(state1, key0);
+	state1 = aesenc<softAes>(state1, key0); \
-		state2 = aesdec<softAes>(state2, key4);
+	state2 = aesdec<softAes>(state2, key4); \
-		state3 = aesenc<softAes>(state3, key4);
+	state3 = aesenc<softAes>(state3, key4); \
-
+	state0 = aesdec<softAes>(state0, key1); \
-		state0 = aesdec<softAes>(state0, key1);
+	state1 = aesenc<softAes>(state1, key1); \
-		state1 = aesenc<softAes>(state1, key1);
+	state2 = aesdec<softAes>(state2, key5); \
-		state2 = aesdec<softAes>(state2, key5);
+	state3 = aesenc<softAes>(state3, key5); \
-		state3 = aesenc<softAes>(state3, key5);
+	state0 = aesdec<softAes>(state0, key2); \
-
+	state1 = aesenc<softAes>(state1, key2); \
-		state0 = aesdec<softAes>(state0, key2);
+	state2 = aesdec<softAes>(state2, key6); \
-		state1 = aesenc<softAes>(state1, key2);
+	state3 = aesenc<softAes>(state3, key6); \
-		state2 = aesdec<softAes>(state2, key6);
+	state0 = aesdec<softAes>(state0, key3); \
-		state3 = aesenc<softAes>(state3, key6);
+	state1 = aesenc<softAes>(state1, key3); \
-
+	state2 = aesdec<softAes>(state2, key7); \
-		state0 = aesdec<softAes>(state0, key3);
+	state3 = aesenc<softAes>(state3, key7); \
-		state1 = aesenc<softAes>(state1, key3);
+} while (0)
-		state2 = aesdec<softAes>(state2, key7);
-		state3 = aesenc<softAes>(state3, key7);
 
+	for (int i = 0; i < 2; ++i, outptr += 64) {
+		TRANSFORM;
 		rx_store_vec_i128((rx_vec_i128*)outptr + 0, state0);
 		rx_store_vec_i128((rx_vec_i128*)outptr + 1, state1);
 		rx_store_vec_i128((rx_vec_i128*)outptr + 2, state2);
 		rx_store_vec_i128((rx_vec_i128*)outptr + 3, state3);
+	}
 
+	static_assert(sizeof(inst_mask) == sizeof(rx_vec_i128), "Incorrect inst_mask size");
+	const rx_vec_i128 mask = *reinterpret_cast<const rx_vec_i128*>(inst_mask);
+
+	while (outptr < outputEnd) {
+		TRANSFORM;
+		rx_store_vec_i128((rx_vec_i128*)outptr + 0, rx_and_vec_i128(state0, mask));
+		rx_store_vec_i128((rx_vec_i128*)outptr + 1, rx_and_vec_i128(state1, mask));
+		rx_store_vec_i128((rx_vec_i128*)outptr + 2, rx_and_vec_i128(state2, mask));
+		rx_store_vec_i128((rx_vec_i128*)outptr + 3, rx_and_vec_i128(state3, mask));
 		outptr += 64;
 	}
 }

src/crypto/randomx/intrin_portable.h

@@ -126,6 +126,7 @@ FORCE_INLINE rx_vec_f128 rx_set1_vec_f128(uint64_t x) {
 
 #define rx_xor_vec_f128 _mm_xor_pd
 #define rx_and_vec_f128 _mm_and_pd
+#define rx_and_vec_i128 _mm_and_si128
 #define rx_or_vec_f128 _mm_or_pd
 
 #ifdef __AES__
@@ -278,6 +279,10 @@ FORCE_INLINE rx_vec_f128 rx_and_vec_f128(rx_vec_f128 a, rx_vec_f128 b) {
 	return (rx_vec_f128)vec_and(a,b);
 }
 
+FORCE_INLINE rx_vec_i128 rx_and_vec_i128(rx_vec_i128 a, rx_vec_i128 b) {
+	return (rx_vec_i128)vec_and(a, b);
+}
+
 FORCE_INLINE rx_vec_f128 rx_or_vec_f128(rx_vec_f128 a, rx_vec_f128 b) {
 	return (rx_vec_f128)vec_or(a,b);
 }
@@ -444,6 +449,8 @@ FORCE_INLINE rx_vec_f128 rx_and_vec_f128(rx_vec_f128 a, rx_vec_f128 b) {
 	return vreinterpretq_f64_u8(vandq_u8(vreinterpretq_u8_f64(a), vreinterpretq_u8_f64(b)));
 }
 
+#define rx_and_vec_i128 vandq_u8
+
 FORCE_INLINE rx_vec_f128 rx_or_vec_f128(rx_vec_f128 a, rx_vec_f128 b) {
 	return vreinterpretq_f64_u8(vorrq_u8(vreinterpretq_u8_f64(a), vreinterpretq_u8_f64(b)));
 }
@@ -635,6 +642,13 @@ FORCE_INLINE rx_vec_f128 rx_and_vec_f128(rx_vec_f128 a, rx_vec_f128 b) {
 	return x;
 }
 
+FORCE_INLINE rx_vec_i128 rx_and_vec_i128(rx_vec_i128 a, rx_vec_i128 b) {
+	rx_vec_i128 x;
+	x.u64[0] = a.u64[0] & b.u64[0];
+	x.u64[1] = a.u64[1] & b.u64[1];
+	return x;
+}
+
 FORCE_INLINE rx_vec_f128 rx_or_vec_f128(rx_vec_f128 a, rx_vec_f128 b) {
 	rx_vec_f128 x;
 	x.i.u64[0] = a.i.u64[0] | b.i.u64[0];

src/crypto/randomx/jit_compiler_a64.cpp

@@ -144,8 +144,6 @@ void JitCompilerA64::generateProgram(Program& program, ProgramConfiguration& con
 	for (uint32_t i = 0; i < program.getSize(); ++i)
 	{
 		Instruction& instr = program(i);
-		instr.src %= RegistersCount;
-		instr.dst %= RegistersCount;
 		(this->*engine[instr.opcode])(instr, codePos);
 	}
 
@@ -204,8 +202,6 @@ void JitCompilerA64::generateProgramLight(Program& program, ProgramConfiguration
 	for (uint32_t i = 0; i < program.getSize(); ++i)
 	{
 		Instruction& instr = program(i);
-		instr.src %= RegistersCount;
-		instr.dst %= RegistersCount;
 		(this->*engine[instr.opcode])(instr, codePos);
 	}
 

src/crypto/randomx/jit_compiler_x86.cpp

@@ -312,11 +312,19 @@ namespace randomx {
 		freePagedMemory(allocatedCode, allocatedSize);
 	}
 
+	template<size_t N>
+	static FORCE_INLINE void prefetch_data(const void* data) {
+		rx_prefetch_nta(data);
+		prefetch_data<N - 1>(reinterpret_cast<const char*>(data) + 64);
+	}
+
+	template<> FORCE_INLINE void prefetch_data<0>(const void*) {}
+
+	template<typename T> static FORCE_INLINE void prefetch_data(const T& data) { prefetch_data<(sizeof(T) + 63) / 64>(&data); }
+
 	void JitCompilerX86::prepare() {
-		for (size_t i = 0; i < sizeof(engine); i += 64)
+		prefetch_data(engine);
-			rx_prefetch_nta((const char*)(&engine) + i);
+		prefetch_data(RandomX_CurrentConfig);
-		for (size_t i = 0; i < sizeof(RandomX_CurrentConfig); i += 64)
-			rx_prefetch_nta((const char*)(&RandomX_CurrentConfig) + i);
 	}
 
 	void JitCompilerX86::generateProgram(Program& prog, ProgramConfiguration& pcfg, uint32_t flags) {
@@ -748,7 +756,7 @@ namespace randomx {
 	template void JitCompilerX86::genAddressReg<true>(const Instruction& instr, const uint32_t src, uint8_t* code, uint32_t& codePos);
 
 	FORCE_INLINE void JitCompilerX86::genAddressRegDst(const Instruction& instr, uint8_t* code, uint32_t& codePos) {
-		const uint32_t dst = static_cast<uint32_t>(instr.dst % RegistersCount) << 16;
+		const uint32_t dst = static_cast<uint32_t>(instr.dst) << 16;
 		*(uint32_t*)(code + codePos) = 0x24808d41 + dst;
 		codePos += (dst == (RegisterNeedsSib << 16)) ? 4 : 3;
 
@@ -768,8 +776,8 @@ namespace randomx {
 		uint32_t pos = codePos;
 		uint8_t* const p = code + pos;
 
-		const uint32_t dst = instr.dst % RegistersCount;
+		const uint32_t dst = instr.dst;
-		const uint32_t sib = (instr.getModShift() << 6) | ((instr.src % RegistersCount) << 3) | dst;
+		const uint32_t sib = (instr.getModShift() << 6) | (instr.src << 3) | dst;
 
 		uint32_t k = 0x048d4f + (dst << 19);
 		if (dst == RegisterNeedsDisplacement)
@@ -788,8 +796,8 @@ namespace randomx {
 		uint8_t* const p = code;
 		uint32_t pos = codePos;
 
-		const uint32_t src = instr.src % RegistersCount;
+		const uint32_t src = instr.src;
-		const uint32_t dst = instr.dst % RegistersCount;
+		const uint32_t dst = instr.dst;
 
 		if (src != dst) {
 			genAddressReg<true>(instr, src, p, pos);
@@ -809,8 +817,8 @@ namespace randomx {
 		uint8_t* const p = code;
 		uint32_t pos = codePos;
 		
-		const uint32_t src = instr.src % RegistersCount;
+		const uint32_t src = instr.src;
-		const uint32_t dst = instr.dst % RegistersCount;
+		const uint32_t dst = instr.dst;
 
 		if (src != dst) {
 			*(uint32_t*)(p + pos) = 0xc02b4d + (dst << 19) + (src << 16);
@@ -830,8 +838,8 @@ namespace randomx {
 		uint8_t* const p = code;
 		uint32_t pos = codePos;
 
-		const uint32_t src = instr.src % RegistersCount;
+		const uint32_t src = instr.src;
-		const uint32_t dst = instr.dst % RegistersCount;
+		const uint32_t dst = instr.dst;
 
 		if (src != dst) {
 			genAddressReg<true>(instr, src, p, pos);
@@ -851,8 +859,8 @@ namespace randomx {
 		uint8_t* const p = code;
 		uint32_t pos = codePos;
 
-		const uint32_t src = instr.src % RegistersCount;
+		const uint32_t src = instr.src;
-		const uint32_t dst = instr.dst % RegistersCount;
+		const uint32_t dst = instr.dst;
 
 		if (src != dst) {
 			emit32(0xc0af0f4d + ((dst * 8 + src) << 24), p, pos);
@@ -871,8 +879,8 @@ namespace randomx {
 		uint8_t* const p = code;
 		uint32_t pos = codePos;
 
-		const uint64_t src = instr.src % RegistersCount;
+		const uint64_t src = instr.src;
-		const uint64_t dst = instr.dst % RegistersCount;
+		const uint64_t dst = instr.dst;
 
 		if (src != dst) {
 			genAddressReg<true>(instr, src, p, pos);
@@ -892,8 +900,8 @@ namespace randomx {
 		uint8_t* const p = code;
 		uint32_t pos = codePos;
 
-		const uint32_t src = instr.src % RegistersCount;
+		const uint32_t src = instr.src;
-		const uint32_t dst = instr.dst % RegistersCount;
+		const uint32_t dst = instr.dst;
 
 		*(uint32_t*)(p + pos) = 0xc08b49 + (dst << 16);
 		*(uint32_t*)(p + pos + 3) = 0xe0f749 + (src << 16);
@@ -908,8 +916,8 @@ namespace randomx {
 		uint8_t* const p = code;
 		uint32_t pos = codePos;
 
-		const uint32_t src = instr.src % RegistersCount;
+		const uint32_t src = instr.src;
-		const uint32_t dst = instr.dst % RegistersCount;
+		const uint32_t dst = instr.dst;
 
 		*(uint32_t*)(p + pos) = 0xC4D08B49 + (dst << 16);
 		*(uint32_t*)(p + pos + 4) = 0xC0F6FB42 + (dst << 27) + (src << 24);
@@ -923,8 +931,8 @@ namespace randomx {
 		uint8_t* const p = code;
 		uint32_t pos = codePos;
 
-		const uint64_t src = instr.src % RegistersCount;
+		const uint64_t src = instr.src;
-		const uint64_t dst = instr.dst % RegistersCount;
+		const uint64_t dst = instr.dst;
 
 		if (src != dst) {
 			genAddressReg<false>(instr, src, p, pos);
@@ -947,8 +955,8 @@ namespace randomx {
 		uint8_t* const p = code;
 		uint32_t pos = codePos;
 
-		const uint64_t src = instr.src % RegistersCount;
+		const uint64_t src = instr.src;
-		const uint64_t dst = instr.dst % RegistersCount;
+		const uint64_t dst = instr.dst;
 
 		if (src != dst) {
 			genAddressReg<false>(instr, src, p, pos);
@@ -970,8 +978,8 @@ namespace randomx {
 		uint8_t* const p = code;
 		uint32_t pos = codePos;
 
-		const uint64_t src = instr.src % RegistersCount;
+		const uint64_t src = instr.src;
-		const uint64_t dst = instr.dst % RegistersCount;
+		const uint64_t dst = instr.dst;
 
 		*(uint64_t*)(p + pos) = 0x8b4ce8f749c08b49ull + (dst << 16) + (src << 40);
 		pos += 8;
@@ -985,8 +993,8 @@ namespace randomx {
 		uint8_t* const p = code;
 		uint32_t pos = codePos;
 
-		const uint64_t src = instr.src % RegistersCount;
+		const uint64_t src = instr.src;
-		const uint64_t dst = instr.dst % RegistersCount;
+		const uint64_t dst = instr.dst;
 
 		if (src != dst) {
 			genAddressReg<false>(instr, src, p, pos);
@@ -1011,7 +1019,7 @@ namespace randomx {
 		
 		uint64_t divisor = instr.getImm32();
 		if (!isZeroOrPowerOf2(divisor)) {
-			const uint32_t dst = instr.dst % RegistersCount;
+			const uint32_t dst = instr.dst;
 
 			const uint64_t reciprocal = randomx_reciprocal_fast(divisor);
 			if (imul_rcp_storage_used < 16) {
@@ -1040,7 +1048,7 @@ namespace randomx {
 		uint8_t* const p = code;
 		uint32_t pos = codePos;
 
-		const uint32_t dst = instr.dst % RegistersCount;
+		const uint32_t dst = instr.dst;
 		*(uint32_t*)(p + pos) = 0xd8f749 + (dst << 16);
 		pos += 3;
 
@@ -1052,8 +1060,8 @@ namespace randomx {
 		uint8_t* const p = code;
 		uint32_t pos = codePos;
 
-		const uint64_t src = instr.src % RegistersCount;
+		const uint64_t src = instr.src;
-		const uint64_t dst = instr.dst % RegistersCount;
+		const uint64_t dst = instr.dst;
 
 		if (src != dst) {
 			*(uint32_t*)(p + pos) = 0xc0334d + (((dst << 3) + src) << 16);
@@ -1073,8 +1081,8 @@ namespace randomx {
 		uint8_t* const p = code;
 		uint32_t pos = codePos;
 
-		const uint64_t src = instr.src % RegistersCount;
+		const uint64_t src = instr.src;
-		const uint64_t dst = instr.dst % RegistersCount;
+		const uint64_t dst = instr.dst;
 
 		if (src != dst) {
 			genAddressReg<true>(instr, src, p, pos);
@@ -1094,8 +1102,8 @@ namespace randomx {
 		uint8_t* const p = code;
 		uint32_t pos = codePos;
 
-		const uint64_t src = instr.src % RegistersCount;
+		const uint64_t src = instr.src;
-		const uint64_t dst = instr.dst % RegistersCount;
+		const uint64_t dst = instr.dst;
 
 		if (src != dst) {
 			*(uint64_t*)(p + pos) = 0xc8d349c88b41ull + (src << 16) + (dst << 40);
@@ -1115,8 +1123,8 @@ namespace randomx {
 		uint8_t* const p = code;
 		uint32_t pos = codePos;
 
-		const uint64_t src = instr.src % RegistersCount;
+		const uint64_t src = instr.src;
-		const uint64_t dst = instr.dst % RegistersCount;
+		const uint64_t dst = instr.dst;
 
 		if (src != dst) {
 			*(uint64_t*)(p + pos) = 0xc0d349c88b41ull + (src << 16) + (dst << 40);
@@ -1136,8 +1144,8 @@ namespace randomx {
 		uint8_t* const p = code;
 		uint32_t pos = codePos;
 
-		const uint32_t src = instr.src % RegistersCount;
+		const uint32_t src = instr.src;
-		const uint32_t dst = instr.dst % RegistersCount;
+		const uint32_t dst = instr.dst;
 
 		if (src != dst) {
 			*(uint32_t*)(p + pos) = 0xc0874d + (((dst << 3) + src) << 16);
@@ -1153,7 +1161,7 @@ namespace randomx {
 		uint8_t* const p = code;
 		uint32_t pos = codePos;
 
-		const uint64_t dst = instr.dst % RegistersCount;
+		const uint64_t dst = instr.dst;
 
 		*(uint64_t*)(p + pos) = 0x01c0c60f66ull + (((dst << 3) + dst) << 24);
 		pos += 5;
@@ -1182,7 +1190,7 @@ namespace randomx {
 
 		prevFPOperation = pos;
 
-		const uint32_t src = instr.src % RegistersCount;
+		const uint32_t src = instr.src;
 		const uint32_t dst = instr.dst % RegisterCountFlt;
 
 		genAddressReg<true>(instr, src, p, pos);
@@ -1214,7 +1222,7 @@ namespace randomx {
 
 		prevFPOperation = pos;
 
-		const uint32_t src = instr.src % RegistersCount;
+		const uint32_t src = instr.src;
 		const uint32_t dst = instr.dst % RegisterCountFlt;
 
 		genAddressReg<true>(instr, src, p, pos);
@@ -1257,7 +1265,7 @@ namespace randomx {
 
 		prevFPOperation = pos;
 
-		const uint32_t src = instr.src % RegistersCount;
+		const uint32_t src = instr.src;
 		const uint64_t dst = instr.dst % RegisterCountFlt;
 
 		genAddressReg<true>(instr, src, p, pos);
@@ -1307,7 +1315,7 @@ namespace randomx {
 		uint32_t pos = codePos;
 		prevCFROUND = pos;
 
-		const uint32_t src = instr.src % RegistersCount;
+		const uint32_t src = instr.src;
 
 		*(uint32_t*)(p + pos) = 0x00C08B49 + (src << 16);
 		const int rotate = (static_cast<int>(instr.getImm32() & 63) - 2) & 63;
@@ -1343,7 +1351,7 @@ namespace randomx {
 		uint32_t pos = codePos;
 		prevCFROUND = pos;
 
-		const uint64_t src = instr.src % RegistersCount;
+		const uint64_t src = instr.src;
 
 		const uint64_t rotate = (static_cast<int>(instr.getImm32() & 63) - 2) & 63;
 		*(uint64_t*)(p + pos) = 0xC0F0FBC3C4ULL | (src << 32) | (rotate << 40);
@@ -1367,7 +1375,7 @@ namespace randomx {
 		uint8_t* const p = code;
 		uint32_t pos = codePos;
 
-		const int reg = instr.dst % RegistersCount;
+		const int reg = instr.dst;
 		int32_t jmp_offset = registerUsage[reg];
 
 		// if it jumps over the previous FP instruction that uses rounding, treat it as if FP instruction happened now
@@ -1426,7 +1434,7 @@ namespace randomx {
 		uint32_t pos = codePos;
 
 		genAddressRegDst(instr, p, pos);
-		emit32(0x0604894c + (static_cast<uint32_t>(instr.src % RegistersCount) << 19), p, pos);
+		emit32(0x0604894c + (static_cast<uint32_t>(instr.src) << 19), p, pos);
 
 		codePos = pos;
 	}

src/crypto/rx/RxConfig.cpp

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2018-2023 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2016-2023 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,11 +22,6 @@
 #include "base/io/json/Json.h"
 
 
-#ifdef XMRIG_FEATURE_HWLOC
-#   include "backend/cpu/platform/HwlocCpuInfo.h"
-#endif
-
-
 #include <array>
 #include <algorithm>
 #include <cmath>
@@ -190,7 +185,7 @@ std::vector<uint32_t> xmrig::RxConfig::nodeset() const
         return m_nodeset;
     }
 
-    return (m_numa && Cpu::info()->nodes() > 1) ? static_cast<HwlocCpuInfo *>(Cpu::info())->nodeset() : std::vector<uint32_t>();
+    return (m_numa && Cpu::info()->nodes() > 1) ? Cpu::info()->nodeset() : std::vector<uint32_t>();
 }
 #endif
 

src/crypto/rx/RxConfig.h

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2018-2023 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2016-2023 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
@@ -123,7 +123,7 @@ private:
 };
 
 
-} /* namespace xmrig */
+} // namespace xmrig
 
 
-#endif /* XMRIG_RXCONFIG_H */
+#endif // XMRIG_RXCONFIG_H

src/crypto/rx/RxNUMAStorage.cpp

@@ -1,7 +1,7 @@
 /* XMRig
  * Copyright (c) 2018-2019 tevador     <tevador@gmail.com>
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2018-2023 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2016-2023 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,7 +19,6 @@
 
 #include "crypto/rx/RxNUMAStorage.h"
 #include "backend/cpu/Cpu.h"
-#include "backend/cpu/platform/HwlocCpuInfo.h"
 #include "base/io/log/Log.h"
 #include "base/io/log/Tags.h"
 #include "base/kernel/Platform.h"
@@ -45,13 +44,12 @@ static std::mutex mutex;
 
 static bool bindToNUMANode(uint32_t nodeId)
 {
-    auto cpu         = static_cast<HwlocCpuInfo *>(Cpu::info());
+    auto node = hwloc_get_numanode_obj_by_os_index(Cpu::info()->topology(), nodeId);
-    hwloc_obj_t node = hwloc_get_numanode_obj_by_os_index(cpu->topology(), nodeId);
     if (!node) {
         return false;
     }
 
-    if (cpu->membind(node->nodeset)) {
+    if (Cpu::info()->membind(node->nodeset)) {
         Platform::setThreadAffinity(static_cast<uint64_t>(hwloc_bitmap_first(node->cpuset)));
 
         return true;

src/net/Network.cpp

@@ -1,7 +1,7 @@
 /* XMRig
  * Copyright (c) 2019      Howard Chu  <https://github.com/hyc>
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2018-2023 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2016-2023 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
@@ -292,8 +292,7 @@ void xmrig::Network::setJob(IClient *client, const Job &job, bool donate)
     }
 
     if (!donate && m_donate) {
-        m_donate->setAlgo(job.algorithm());
+        static_cast<DonateStrategy *>(m_donate)->update(client, job);
-        m_donate->setProxy(client->pool().proxy());
     }
 
     m_controller->miner()->setJob(job, donate);
@@ -309,6 +308,10 @@ void xmrig::Network::tick()
     if (m_donate) {
         m_donate->tick(now);
     }
+
+#   ifdef XMRIG_FEATURE_API
+    m_controller->api()->tick();
+#   endif
 }
 
 

src/net/Network.h

@@ -1,7 +1,7 @@
 /* XMRig
  * Copyright (c) 2019      Howard Chu  <https://github.com/hyc>
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2018-2023 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2016-2023 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
@@ -89,7 +89,7 @@ private:
 };
 
 
-} /* namespace xmrig */
+} // namespace xmrig
 
 
-#endif /* XMRIG_NETWORK_H */
+#endif // XMRIG_NETWORK_H

src/net/strategies/DonateStrategy.cpp

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2022 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2018-2023 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2022 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2016-2023 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
@@ -48,7 +48,7 @@ static const char *kDonateHost = "donate.v2.xmrig.com";
 static const char *kDonateHostTls = "donate.ssl.xmrig.com";
 #endif
 
-} /* namespace xmrig */
+} // namespace xmrig
 
 
 xmrig::DonateStrategy::DonateStrategy(Controller *controller, IStrategyListener *listener) :
@@ -98,6 +98,17 @@ xmrig::DonateStrategy::~DonateStrategy()
 }
 
 
+void xmrig::DonateStrategy::update(IClient *client, const Job &job)
+{
+    setAlgo(job.algorithm());
+    setProxy(client->pool().proxy());
+
+    m_diff   = job.diff();
+    m_height = job.height();
+    m_seed   = job.seed();
+}
+
+
 int64_t xmrig::DonateStrategy::submit(const JobResult &result)
 {
     return m_proxy ? m_proxy->submit(result) : m_strategy->submit(result);
@@ -199,13 +210,13 @@ void xmrig::DonateStrategy::onLogin(IClient *, rapidjson::Document &doc, rapidjs
     params.AddMember("url", m_pools[0].url().toJSON(), allocator);
 #   endif
 
-    setAlgorithms(doc, params);
+    setParams(doc, params);
 }
 
 
 void xmrig::DonateStrategy::onLogin(IStrategy *, IClient *, rapidjson::Document &doc, rapidjson::Value &params)
 {
-    setAlgorithms(doc, params);
+    setParams(doc, params);
 }
 
 
@@ -270,12 +281,20 @@ void xmrig::DonateStrategy::idle(double min, double max)
 }
 
 
-void xmrig::DonateStrategy::setAlgorithms(rapidjson::Document &doc, rapidjson::Value &params)
+void xmrig::DonateStrategy::setJob(IClient *client, const Job &job, const rapidjson::Value &params)
+{
+    if (isActive()) {
+        m_listener->onJob(this, client, job, params);
+    }
+}
+
+
+void xmrig::DonateStrategy::setParams(rapidjson::Document &doc, rapidjson::Value &params)
 {
     using namespace rapidjson;
     auto &allocator = doc.GetAllocator();
+    auto algorithms = m_controller->miner()->algorithms();
 
-    Algorithms algorithms = m_controller->miner()->algorithms();
     const size_t index = static_cast<size_t>(std::distance(algorithms.begin(), std::find(algorithms.begin(), algorithms.end(), m_algorithm)));
     if (index > 0 && index < algorithms.size()) {
         std::swap(algorithms[0], algorithms[index]);
@@ -287,14 +306,12 @@ void xmrig::DonateStrategy::setAlgorithms(rapidjson::Document &doc, rapidjson::V
         algo.PushBack(StringRef(a.name()), allocator);
     }
 
-    params.AddMember("algo", algo, allocator);
+    params.AddMember("algo",    algo, allocator);
-}
+    params.AddMember("diff",    m_diff, allocator);
+    params.AddMember("height",  m_height, allocator);
 
-
+    if (!m_seed.empty()) {
-void xmrig::DonateStrategy::setJob(IClient *client, const Job &job, const rapidjson::Value &params)
+       params.AddMember("seed_hash", Cvt::toHex(m_seed, doc), allocator);
-{
-    if (isActive()) {
-        m_listener->onJob(this, client, job, params);
     }
 }
 

src/net/strategies/DonateStrategy.h

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2022 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2018-2023 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2022 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2016-2023 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
@@ -20,15 +20,12 @@
 #define XMRIG_DONATESTRATEGY_H
 
 
-#include <vector>
-
-
 #include "base/kernel/interfaces/IClientListener.h"
 #include "base/kernel/interfaces/IStrategy.h"
 #include "base/kernel/interfaces/IStrategyListener.h"
 #include "base/kernel/interfaces/ITimerListener.h"
 #include "base/net/stratum/Pool.h"
-#include "base/tools/Object.h"
+#include "base/tools/Buffer.h"
 
 
 namespace xmrig {
@@ -36,7 +33,6 @@ namespace xmrig {
 
 class Client;
 class Controller;
-class IStrategyListener;
 
 
 class DonateStrategy : public IStrategy, public IStrategyListener, public ITimerListener, public IClientListener
@@ -47,6 +43,8 @@ public:
     DonateStrategy(Controller *controller, IStrategyListener *listener);
     ~DonateStrategy() override;
 
+    void update(IClient *client, const Job &job);
+
 protected:
     inline bool isActive() const override                                                                              { return state() == STATE_ACTIVE; }
     inline IClient *client() const override                                                                            { return m_proxy ? m_proxy : m_strategy->client(); }
@@ -88,13 +86,14 @@ private:
 
     IClient *createProxy();
     void idle(double min, double max);
-    void setAlgorithms(rapidjson::Document &doc, rapidjson::Value &params);
     void setJob(IClient *client, const Job &job, const rapidjson::Value &params);
+    void setParams(rapidjson::Document &doc, rapidjson::Value &params);
     void setResult(IClient *client, const SubmitResult &result, const char *error);
     void setState(State state);
 
     Algorithm m_algorithm;
     bool m_tls                      = false;
+    Buffer m_seed;
     char m_userId[65]               = { 0 };
     const uint64_t m_donateTime;
     const uint64_t m_idleTime;
@@ -105,12 +104,14 @@ private:
     State m_state                   = STATE_NEW;
     std::vector<Pool> m_pools;
     Timer *m_timer                  = nullptr;
+    uint64_t m_diff                 = 0;
+    uint64_t m_height               = 0;
     uint64_t m_now                  = 0;
     uint64_t m_timestamp            = 0;
 };
 
 
-} /* namespace xmrig */
+} // namespace xmrig
 
 
-#endif /* XMRIG_DONATESTRATEGY_H */
+#endif // XMRIG_DONATESTRATEGY_H

src/version.h

@@ -22,15 +22,15 @@
 #define APP_ID        "xmrig"
 #define APP_NAME      "XMRig"
 #define APP_DESC      "XMRig miner"
-#define APP_VERSION   "6.19.2"
+#define APP_VERSION   "6.20.1-dev"
 #define APP_DOMAIN    "xmrig.com"
 #define APP_SITE      "www.xmrig.com"
 #define APP_COPYRIGHT "Copyright (C) 2016-2023 xmrig.com"
 #define APP_KIND      "miner"
 
 #define APP_VER_MAJOR  6
-#define APP_VER_MINOR  19
+#define APP_VER_MINOR  20
-#define APP_VER_PATCH  2
+#define APP_VER_PATCH  1
 
 #ifdef _MSC_VER
 #   if (_MSC_VER >= 1930)