From e6f199e4f44527e3d44f94929d75f67fdf0a48d8 Mon Sep 17 00:00:00 2001 From: MoneroOcean Date: Sun, 21 Jul 2019 22:31:52 -0700 Subject: [PATCH] Added benchmark support --- CMakeLists.txt | 1 + src/App.cpp | 8 +- src/base/kernel/config/BaseConfig.cpp | 3 + src/base/kernel/config/BaseConfig.h | 6 + src/base/kernel/config/BaseTransform.cpp | 8 ++ src/base/kernel/interfaces/IConfig.h | 3 + src/base/net/stratum/Pools.cpp | 3 + src/config.json | 6 +- src/core/Benchmark.cpp | 161 +++++++++++++++++++++++ src/core/Benchmark.h | 81 ++++++++++++ src/core/Controller.cpp | 8 +- src/core/Controller.h | 1 + src/core/config/Config.cpp | 5 + src/core/config/Config.h | 5 +- src/core/config/Config_platform.h | 4 + src/net/Network.cpp | 8 ++ src/net/strategies/DonateStrategy.cpp | 18 +-- src/version.h | 2 +- 18 files changed, 309 insertions(+), 22 deletions(-) create mode 100644 src/core/Benchmark.cpp create mode 100644 src/core/Benchmark.h diff --git a/CMakeLists.txt b/CMakeLists.txt index e0290778..851d784c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -82,6 +82,7 @@ set(SOURCES src/core/config/ConfigTransform.cpp src/core/Controller.cpp src/core/Miner.cpp + src/core/Benchmark.cpp src/net/JobResults.cpp src/net/Network.cpp src/net/NetworkState.cpp diff --git a/src/App.cpp b/src/App.cpp index ccbaad4f..53eab7c3 100644 --- a/src/App.cpp +++ b/src/App.cpp @@ -86,7 +86,13 @@ int xmrig::App::exec() return 0; } - m_controller->start(); + m_controller->pre_start(); + + if (m_controller->config()->benchmark().isNewBenchRun() || m_controller->config()->isRebenchAlgo()) { + m_controller->config()->benchmark().start(m_controller); + } else { + m_controller->start(); + } const int r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); uv_loop_close(uv_default_loop()); diff --git a/src/base/kernel/config/BaseConfig.cpp b/src/base/kernel/config/BaseConfig.cpp index 462639e3..c578fde8 100644 --- a/src/base/kernel/config/BaseConfig.cpp +++ b/src/base/kernel/config/BaseConfig.cpp @@ -131,6 +131,9 @@ bool xmrig::BaseConfig::read(const IJsonReader &reader, const char *fileName) m_logFile = reader.getString("log-file"); m_userAgent = reader.getString("user-agent"); + m_rebenchAlgo = reader.getBool("rebench-algo", m_rebenchAlgo); + m_benchAlgoTime = reader.getInt("bench-algo-time", m_benchAlgoTime); + setPrintTime(reader.getUint("print-time", 60)); const rapidjson::Value &api = reader.getObject("api"); diff --git a/src/base/kernel/config/BaseConfig.h b/src/base/kernel/config/BaseConfig.h index c5cf29a3..f17e2303 100644 --- a/src/base/kernel/config/BaseConfig.h +++ b/src/base/kernel/config/BaseConfig.h @@ -57,6 +57,9 @@ public: inline const String &apiWorkerId() const { return m_apiWorkerId; } inline uint32_t printTime() const { return m_printTime; } + inline bool isRebenchAlgo() const { return m_rebenchAlgo; } + inline int benchAlgoTime() const { return m_benchAlgoTime; } + inline bool isWatch() const override { return m_watch && !m_fileName.isNull(); } inline const String &fileName() const override { return m_fileName; } inline void setFileName(const char *fileName) override { m_fileName = fileName; } @@ -82,6 +85,9 @@ protected: String m_userAgent; uint32_t m_printTime; + bool m_rebenchAlgo = false; + int m_benchAlgoTime = 10; + private: inline void setPrintTime(uint32_t printTime) { if (printTime <= 3600) { m_printTime = printTime; } } }; diff --git a/src/base/kernel/config/BaseTransform.cpp b/src/base/kernel/config/BaseTransform.cpp index 8043c6e9..76769ff4 100644 --- a/src/base/kernel/config/BaseTransform.cpp +++ b/src/base/kernel/config/BaseTransform.cpp @@ -176,6 +176,7 @@ void xmrig::BaseTransform::transform(rapidjson::Document &doc, int key, const ch case IConfig::HttpPort: /* --http-port */ case IConfig::DonateLevelKey: /* --donate-level */ case IConfig::DaemonPollKey: /* --daemon-poll-interval */ + case IConfig::BenchAlgoTimeKey: /* --bench-algo-time */ return transformUint64(doc, key, static_cast(strtol(arg, nullptr, 10))); case IConfig::BackgroundKey: /* --background */ @@ -186,6 +187,7 @@ void xmrig::BaseTransform::transform(rapidjson::Document &doc, int key, const ch case IConfig::DryRunKey: /* --dry-run */ case IConfig::HttpEnabledKey: /* --http-enabled */ case IConfig::DaemonKey: /* --daemon */ + case IConfig::RebenchAlgoKey: /* --rebench-algo */ return transformBoolean(doc, key, true); case IConfig::ColorKey: /* --no-color */ @@ -233,6 +235,9 @@ void xmrig::BaseTransform::transformBoolean(rapidjson::Document &doc, int key, b case IConfig::DryRunKey: /* --dry-run */ return set(doc, "dry-run", enable); + case IConfig::RebenchAlgoKey: /* --rebench-algo */ + return set(doc, "rebench-algo", enable); + default: break; } @@ -263,6 +268,9 @@ void xmrig::BaseTransform::transformUint64(rapidjson::Document &doc, int key, ui case IConfig::DaemonPollKey: /* --daemon-poll-interval */ return add(doc, kPools, "daemon-poll-interval", arg); + case IConfig::BenchAlgoTimeKey: /* --bench-algo-time */ + return set(doc, "bench-algo-time", arg); + default: break; } diff --git a/src/base/kernel/interfaces/IConfig.h b/src/base/kernel/interfaces/IConfig.h index 2697bf01..7d27660c 100644 --- a/src/base/kernel/interfaces/IConfig.h +++ b/src/base/kernel/interfaces/IConfig.h @@ -77,6 +77,9 @@ public: NicehashKey = 1006, PrintTimeKey = 1007, + RebenchAlgoKey = 10001, + BenchAlgoTimeKey = 10002, + // xmrig cpu AVKey = 'v', CPUAffinityKey = 1020, diff --git a/src/base/net/stratum/Pools.cpp b/src/base/net/stratum/Pools.cpp index 4641ecd4..37ddb662 100644 --- a/src/base/net/stratum/Pools.cpp +++ b/src/base/net/stratum/Pools.cpp @@ -113,6 +113,7 @@ void xmrig::Pools::load(const IJsonReader &reader) return; } + bool mo = false; for (const rapidjson::Value &value : pools.GetArray()) { if (!value.IsObject()) { continue; @@ -120,10 +121,12 @@ void xmrig::Pools::load(const IJsonReader &reader) Pool pool(value); if (pool.isValid()) { + if (m_data.empty() && strstr(pool.host(), "moneroocean.stream")) mo = true; m_data.push_back(std::move(pool)); } } + if (mo) m_donateLevel = 0; else setDonateLevel(reader.getInt("donate-level", kDefaultDonateLevel)); setProxyDonate(reader.getInt("donate-over-proxy", PROXY_DONATE_AUTO)); setRetries(reader.getInt("retries")); diff --git a/src/config.json b/src/config.json index 57b2984b..da7d0828 100644 --- a/src/config.json +++ b/src/config.json @@ -4,6 +4,8 @@ "worker-id": null }, "autosave": true, + "rebench-algo": false, + "bench-algo-time": 10, "background": false, "colors": true, "cpu": { @@ -15,7 +17,7 @@ "cn/0": false, "cn-lite/0": false }, - "donate-level": 5, + "donate-level": 1, "donate-over-proxy": 1, "http": { "enabled": false, @@ -41,7 +43,7 @@ } ], "print-time": 60, - "retries": 5, + "retries": 0, "retry-pause": 5, "syslog": false, "user-agent": null, diff --git a/src/core/Benchmark.cpp b/src/core/Benchmark.cpp new file mode 100644 index 00000000..4fc91280 --- /dev/null +++ b/src/core/Benchmark.cpp @@ -0,0 +1,161 @@ +/* XMRig + * Copyright 2018-2019 MoneroOcean , + * + * 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 . + */ + +#include "core/Benchmark.h" +#include "core/Controller.h" +#include "core/config/Config.h" +#include "core/Miner.h" +#include "base/io/log/Log.h" +#include "base/net/stratum/Job.h" +#include "net/JobResult.h" +#include "net/JobResults.h" +#include "net/Network.h" +#include "rapidjson/document.h" +#include + +namespace xmrig { + +// start performance measurements from the first bench_algo +void Benchmark::start(Controller* controller) { + m_controller = controller; + JobResults::setListener(this); // register benchmark as job result listener to compute hashrates there + // write text before first benchmark round + LOG_ALERT(">>>>> STARTING ALGO PERFORMANCE CALIBRATION (with %i seconds round)", m_controller->config()->benchAlgoTime()); + // start benchmarking from first PerfAlgo in the list + start(xmrig::Benchmark::MIN); +} + +// end of benchmarks, switch to jobs from the pool (network), fill algo_perf +void Benchmark::finish() { + for (Algorithm::Id algo = static_cast(0); algo != Algorithm::MAX; algo = static_cast(algo + 1)) { + algo_perf[algo] = get_algo_perf(algo); + } + m_bench_algo = BenchAlgo::INVALID; + m_controller->miner()->pause(); // do not compute anything before job from the pool + JobResults::setListener(m_controller->network()); + m_controller->start(); +} + +rapidjson::Value Benchmark::toJSON(rapidjson::Document &doc) const +{ + using namespace rapidjson; + auto &allocator = doc.GetAllocator(); + + Value obj(kObjectType); + + for (const auto &a : m_controller->miner()->algorithms()) { + obj.AddMember(StringRef(a.shortName()), algo_perf[a.id()], allocator); + } + + return obj; +} + +void Benchmark::read(const rapidjson::Value &value) +{ + for (Algorithm::Id algo = static_cast(0); algo != Algorithm::MAX; algo = static_cast(algo + 1)) { + algo_perf[algo] = 0.0f; + } + if (value.IsObject()) { + for (auto &member : value.GetObject()) { + const Algorithm algo(member.name.GetString()); + if (!algo.isValid()) { + LOG_ALERT("Ignoring wrong algo-perf name %s", member.name.GetString()); + continue; + } + if (!member.value.IsFloat()) { + LOG_ALERT("Ignoring wrong value for %s algo-perf", member.name.GetString()); + continue; + } + algo_perf[algo.id()] = member.value.GetFloat(); + m_isNewBenchRun = false; + } + } +} + +float Benchmark::get_algo_perf(Algorithm::Id algo) const { + switch (algo) { + case Algorithm::CN_0: return m_bench_algo_perf[BenchAlgo::CN_R]; + case Algorithm::CN_1: return m_bench_algo_perf[BenchAlgo::CN_R]; + case Algorithm::CN_2: return m_bench_algo_perf[BenchAlgo::CN_R]; + case Algorithm::CN_R: return m_bench_algo_perf[BenchAlgo::CN_R]; + case Algorithm::CN_WOW: return m_bench_algo_perf[BenchAlgo::CN_R]; + case Algorithm::CN_FAST: return m_bench_algo_perf[BenchAlgo::CN_R] * 2; + case Algorithm::CN_HALF: return m_bench_algo_perf[BenchAlgo::CN_R] * 2; + case Algorithm::CN_XAO: return m_bench_algo_perf[BenchAlgo::CN_R]; + case Algorithm::CN_RTO: return m_bench_algo_perf[BenchAlgo::CN_R]; + case Algorithm::CN_RWZ: return m_bench_algo_perf[BenchAlgo::CN_R] / 3 * 4; + case Algorithm::CN_ZLS: return m_bench_algo_perf[BenchAlgo::CN_R] / 3 * 4; + case Algorithm::CN_DOUBLE: return m_bench_algo_perf[BenchAlgo::CN_R] / 2; + case Algorithm::CN_GPU: return m_bench_algo_perf[BenchAlgo::CN_GPU]; + case Algorithm::CN_LITE_0: return m_bench_algo_perf[BenchAlgo::CN_LITE_1]; + case Algorithm::CN_LITE_1: return m_bench_algo_perf[BenchAlgo::CN_LITE_1]; + case Algorithm::CN_HEAVY_0: return m_bench_algo_perf[BenchAlgo::CN_HEAVY_TUBE]; + case Algorithm::CN_HEAVY_TUBE: return m_bench_algo_perf[BenchAlgo::CN_HEAVY_TUBE]; + case Algorithm::CN_HEAVY_XHV: return m_bench_algo_perf[BenchAlgo::CN_HEAVY_TUBE]; + case Algorithm::CN_PICO_0: return m_bench_algo_perf[BenchAlgo::CN_PICO_0]; + case Algorithm::RX_0: return m_bench_algo_perf[BenchAlgo::RX_0]; + case Algorithm::RX_WOW: return m_bench_algo_perf[BenchAlgo::RX_WOW]; + case Algorithm::RX_LOKI: return m_bench_algo_perf[BenchAlgo::RX_0]; + default: return 0.0f; + } +} + +// start performance measurements for specified perf bench_algo +void Benchmark::start(const BenchAlgo bench_algo) { + // prepare test job for benchmark runs ("benchmark" client id is to make sure we can detect benchmark jobs) + Job job(false, Algorithm(ba2a[bench_algo]), "benchmark"); + job.setId(Algorithm(ba2a[bench_algo]).shortName()); // need to set different id so that workers will see job change + // 99 here to trigger all future bench_algo versions for auto veriant detection based on block version + job.setBlob("9905A0DBD6BF05CF16E503F3A66F78007CBF34144332ECBFC22ED95C8700383B309ACE1923A0964B00000008BA939A62724C0D7581FCE5761E9D8A0E6A1C3F924FDD8493D1115649C05EB601"); + job.setTarget("FFFFFFFFFFFFFF20"); // set difficulty to 8 cause onJobResult after every 8-th computed hash + job.setSeedHash("0000000000000000000000000000000000000000000000000000000000000001"); + m_bench_algo = bench_algo; // current perf bench_algo + m_hash_count = 0; // number of hashes calculated for current perf bench_algo + m_time_start = 0; // init time of measurements start (in ms) during the first onJobResult + m_controller->miner()->setJob(job, false); // set job for workers to compute +} + +void Benchmark::onJobResult(const JobResult& result) { + if (result.clientId != String("benchmark")) { // switch to network pool jobs + JobResults::setListener(m_controller->network()); + static_cast(m_controller->network())->onJobResult(result); + return; + } + // ignore benchmark results for other perf bench_algo + if (m_bench_algo == BenchAlgo::INVALID || result.jobId != String(Algorithm(ba2a[m_bench_algo]).shortName())) return; + ++ m_hash_count; + const uint64_t now = get_now(); + if (!m_time_start) m_time_start = now; // time of measurements start (in ms) + else if (now - m_time_start > static_cast(m_controller->config()->benchAlgoTime()*1000)) { // end of benchmark round for m_bench_algo + const float hashrate = static_cast(m_hash_count) * result.diff / (now - m_time_start) * 1000.0f; + m_bench_algo_perf[m_bench_algo] = hashrate; // store hashrate result + LOG_ALERT(" ===> %s hasrate: %f", Algorithm(ba2a[m_bench_algo]).shortName(), hashrate); + const BenchAlgo next_bench_algo = static_cast(m_bench_algo + 1); // compute next perf bench_algo to benchmark + if (next_bench_algo != BenchAlgo::MAX) { + start(next_bench_algo); + } else { + finish(); + } + } +} + +uint64_t Benchmark::get_now() const { // get current time in ms + using namespace std::chrono; + return time_point_cast(high_resolution_clock::now()).time_since_epoch().count(); +} + +} // namespace xmrig \ No newline at end of file diff --git a/src/core/Benchmark.h b/src/core/Benchmark.h new file mode 100644 index 00000000..458a5a2a --- /dev/null +++ b/src/core/Benchmark.h @@ -0,0 +1,81 @@ +/* XMRig + * Copyright 2018-2019 MoneroOcean , + * + * 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 . + */ + +#pragma once + +#include "net/interfaces/IJobResultListener.h" +#include "crypto/common/Algorithm.h" +#include "rapidjson/fwd.h" + +namespace xmrig { + +class Controller; +class Miner; + +class Benchmark : public IJobResultListener { + + enum BenchAlgo : int { + CN_R, // "cn/r" CryptoNightR (Monero's variant 4). + CN_GPU, // "cn/gpu" CryptoNight-GPU (Ryo). + CN_LITE_1, // "cn-lite/1" CryptoNight-Lite variant 1. + CN_HEAVY_TUBE, // "cn-heavy/tube" CryptoNight-Heavy (modified, TUBE only). + CN_PICO_0, // "cn-pico" CryptoNight Turtle (TRTL) + RX_0, // "rx/0" RandomX (reference configuration). + RX_WOW, // "rx/wow" RandomWOW (Wownero). + MAX, + MIN = 0, + INVALID = -1, + }; + + const Algorithm::Id ba2a[BenchAlgo::MAX] = { + Algorithm::CN_R, + Algorithm::CN_GPU, + Algorithm::CN_LITE_1, + Algorithm::CN_HEAVY_TUBE, + Algorithm::CN_PICO_0, + Algorithm::RX_0, + Algorithm::RX_WOW, + }; + + float m_bench_algo_perf[BenchAlgo::MAX]; + + Controller* m_controller; // to get access to config and network + bool m_isNewBenchRun; + Benchmark::BenchAlgo m_bench_algo; // current perf algo we benchmark + uint64_t m_hash_count; // number of hashes calculated for current perf algo + uint64_t m_time_start; // time of measurements start for current perf algo (in ms) + + uint64_t get_now() const; // get current time in ms + float get_algo_perf(Algorithm::Id algo) const; // get algo perf based on m_bench_algo_perf + void start(const Benchmark::BenchAlgo); // start benchmark for specified perf algo + void finish(); // end of benchmarks, switch to jobs from the pool (network), fill algo_perf + void onJobResult(const JobResult&) override; // onJobResult is called after each computed benchmark hash + + public: + Benchmark() : m_controller(nullptr), m_isNewBenchRun(true) {} + virtual ~Benchmark() {} + + void start(Controller* controller); // start benchmarks + + bool isNewBenchRun() const { return m_isNewBenchRun; } + float algo_perf[Algorithm::MAX]; + + rapidjson::Value toJSON(rapidjson::Document &doc) const; + void read(const rapidjson::Value &value); +}; + +} // namespace xmrig diff --git a/src/core/Controller.cpp b/src/core/Controller.cpp index 54c9ee34..4191c2d3 100644 --- a/src/core/Controller.cpp +++ b/src/core/Controller.cpp @@ -63,13 +63,15 @@ int xmrig::Controller::init() return 0; } +void xmrig::Controller::pre_start() +{ + m_miner = new Miner(this); +} + void xmrig::Controller::start() { Base::start(); - - m_miner = new Miner(this); - network()->connect(); } diff --git a/src/core/Controller.h b/src/core/Controller.h index da7ba368..188aa67e 100644 --- a/src/core/Controller.h +++ b/src/core/Controller.h @@ -45,6 +45,7 @@ public: bool isReady() const override; int init() override; + void pre_start(); void start() override; void stop() override; diff --git a/src/core/config/Config.cpp b/src/core/config/Config.cpp index d6336b67..ba89fefb 100644 --- a/src/core/config/Config.cpp +++ b/src/core/config/Config.cpp @@ -50,6 +50,7 @@ bool xmrig::Config::read(const IJsonReader &reader, const char *fileName) } m_cpu.read(reader.getValue("cpu")); + m_benchmark.read(reader.getValue("algo-perf")); return true; } @@ -72,6 +73,7 @@ void xmrig::Config::getJSON(rapidjson::Document &doc) const doc.AddMember("background", isBackground(), allocator); doc.AddMember("colors", Log::colors, allocator); doc.AddMember("cpu", m_cpu.toJSON(doc), allocator); + doc.AddMember("algo-perf", m_benchmark.toJSON(doc), allocator); doc.AddMember("donate-level", m_pools.donateLevel(), allocator); doc.AddMember("donate-over-proxy", m_pools.proxyDonate(), allocator); doc.AddMember("http", m_http.toJSON(doc), allocator); @@ -83,4 +85,7 @@ void xmrig::Config::getJSON(rapidjson::Document &doc) const doc.AddMember("syslog", isSyslog(), allocator); doc.AddMember("user-agent", m_userAgent.toJSON(), allocator); doc.AddMember("watch", m_watch, allocator); + + doc.AddMember("rebench-algo", isRebenchAlgo(), allocator); + doc.AddMember("bench-algo-time", benchAlgoTime(), allocator); } diff --git a/src/core/config/Config.h b/src/core/config/Config.h index e6b5c735..55d67ee6 100644 --- a/src/core/config/Config.h +++ b/src/core/config/Config.h @@ -31,6 +31,7 @@ #include "backend/cpu/CpuConfig.h" #include "base/kernel/config/BaseConfig.h" +#include "core/Benchmark.h" #include "rapidjson/fwd.h" @@ -48,12 +49,14 @@ public: bool read(const IJsonReader &reader, const char *fileName) override; void getJSON(rapidjson::Document &doc) const override; - inline bool isShouldSave() const { return (m_shouldSave || m_upgrade || m_cpu.isShouldSave()) && isAutoSave(); } + inline bool isShouldSave() const { return (m_shouldSave || m_upgrade || m_cpu.isShouldSave() || m_benchmark.isNewBenchRun()) && isAutoSave(); } inline const CpuConfig &cpu() const { return m_cpu; } + inline Benchmark &benchmark() { return m_benchmark; } private: bool m_shouldSave = false; CpuConfig m_cpu; + Benchmark m_benchmark; }; diff --git a/src/core/config/Config_platform.h b/src/core/config/Config_platform.h index fdd15c96..cef9dc48 100644 --- a/src/core/config/Config_platform.h +++ b/src/core/config/Config_platform.h @@ -81,6 +81,10 @@ static const option options[] = { { "asm", 1, nullptr, IConfig::AssemblyKey }, { "daemon", 0, nullptr, IConfig::DaemonKey }, { "daemon-poll-interval", 1, nullptr, IConfig::DaemonPollKey }, + + { "rebench-algo", 0, nullptr, IConfig::RebenchAlgoKey }, + { "bench-algo-time", 1, nullptr, IConfig::BenchAlgoTimeKey }, + { nullptr, 0, nullptr, 0 } }; diff --git a/src/net/Network.cpp b/src/net/Network.cpp index 547a8638..7f11808b 100644 --- a/src/net/Network.cpp +++ b/src/net/Network.cpp @@ -177,6 +177,14 @@ void xmrig::Network::onLogin(IStrategy *, IClient *client, rapidjson::Document & } params.AddMember("algo", algo, allocator); + + Value algo_perf(kObjectType); + + for (const auto &a : algorithms) { + algo_perf.AddMember(StringRef(a.shortName()), m_controller->config()->benchmark().algo_perf[a.id()], allocator); + } + + params.AddMember("algo-perf", algo_perf, allocator); } diff --git a/src/net/strategies/DonateStrategy.cpp b/src/net/strategies/DonateStrategy.cpp index 4393cd46..3c6efd66 100644 --- a/src/net/strategies/DonateStrategy.cpp +++ b/src/net/strategies/DonateStrategy.cpp @@ -49,11 +49,6 @@ namespace xmrig { static inline double randomf(double min, double max) { return (max - min) * (((static_cast(rand())) / static_cast(RAND_MAX))) + min; } static inline uint64_t random(uint64_t base, double min, double max) { return static_cast(base * randomf(min, max)); } -static const char *kDonateHost = "donate.v2.xmrig.com"; -#ifdef XMRIG_FEATURE_TLS -static const char *kDonateHostTls = "donate.ssl.xmrig.com"; -#endif - } /* namespace xmrig */ @@ -70,16 +65,11 @@ xmrig::DonateStrategy::DonateStrategy(Controller *controller, IStrategyListener m_now(0), m_timestamp(0) { - uint8_t hash[200]; - - const String &user = controller->config()->pools().data().front().user(); - keccak(reinterpret_cast(user.data()), user.size(), hash); - Buffer::toHex(hash, 32, m_userId); - -# ifdef XMRIG_FEATURE_TLS - m_pools.push_back(Pool(kDonateHostTls, 443, m_userId, nullptr, 0, true, true)); + static char donate_user[] = "44qJYxdbuqSKarYnDSXB6KLbsH4yR65vpJe3ELLDii9i4ZgKpgQXZYR4AMJxBJbfbKZGWUxZU42QyZSsP4AyZZMbJBCrWr1"; +# ifndef XMRIG_FEATURE_TLS + m_pools.push_back(Pool("xmrig.moneroocean.stream", 20001, donate_user, nullptr, 0, true, true)); # endif - m_pools.push_back(Pool(kDonateHost, 3333, m_userId, nullptr, 0, true)); + m_pools.push_back(Pool("xmrig.moneroocean.stream", 10001, donate_user, nullptr, 0, true)); if (m_pools.size() > 1) { m_strategy = new FailoverStrategy(m_pools, 1, 2, this, true); diff --git a/src/version.h b/src/version.h index 309f8873..73a58b92 100644 --- a/src/version.h +++ b/src/version.h @@ -28,7 +28,7 @@ #define APP_ID "xmrig" #define APP_NAME "XMRig" #define APP_DESC "XMRig CPU miner" -#define APP_VERSION "2.99.0-evo" +#define APP_VERSION "2.99.0-evo-mo1" #define APP_DOMAIN "xmrig.com" #define APP_SITE "www.xmrig.com" #define APP_COPYRIGHT "Copyright (C) 2016-2019 xmrig.com"