Ecosystem/xmrig
Ecosystem/xmrig
1
0
Fork 0
mirror of https://github.com/xmrig/xmrig.git synced 2025-01-30 22:46:07 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

replace new/delete with sp

Browse source
This commit is contained in:
4ertus2 2024-10-20 08:24:09 +03:00
parent e32731b60b
commit ab5be0b773
71 changed files with 271 additions and 387 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
src/backend/common/Thread.h
View file

@ -65,22 +65,22 @@ public:
}
}
# else
inline ~Thread() { m_thread.join(); delete m_worker; }
inline ~Thread() { m_thread.join(); }
inline void start(void *(*callback)(void *)) { m_thread = std::thread(callback, this); }
# endif
inline const T &config() const { return m_config; }
inline IBackend *backend() const { return m_backend; }
inline IWorker *worker() const { return m_worker; }
inline IWorker* worker() const { return m_worker.get(); }
inline size_t id() const { return m_id; }
inline void setWorker(IWorker *worker) { m_worker = worker; }
inline void setWorker(std::shared_ptr<IWorker> worker) { m_worker = worker; }
private:
const size_t m_id = 0;
const T m_config;
IBackend *m_backend;
IWorker *m_worker = nullptr;
std::shared_ptr<IWorker> m_worker;
#ifdef XMRIG_OS_APPLE
pthread_t m_thread{};

56
src/backend/common/Workers.cpp
View file

@ -62,19 +62,12 @@ public:
template<class T>
xmrig::Workers<T>::Workers() :
d_ptr(new WorkersPrivate())
d_ptr(std::make_shared<WorkersPrivate>())
{
}
template<class T>
xmrig::Workers<T>::~Workers()
{
delete d_ptr;
}
template<class T>
bool xmrig::Workers<T>::tick(uint64_t)
{
@ -88,7 +81,7 @@ bool xmrig::Workers<T>::tick(uint64_t)
uint64_t hashCount = 0;
uint64_t rawHashes = 0;
for (Thread<T> *handle : m_workers) {
for (auto& handle : m_workers) {
IWorker *worker = handle->worker();
if (worker) {
worker->hashrateData(hashCount, ts, rawHashes);
@ -135,10 +128,6 @@ void xmrig::Workers<T>::stop()
Nonce::stop(T::backend());
# endif
for (Thread<T> *worker : m_workers) {
delete worker;
}
m_workers.clear();
# ifdef XMRIG_MINER_PROJECT
@ -166,7 +155,7 @@ void xmrig::Workers<T>::start(const std::vector<T> &data, const std::shared_ptr<
template<class T>
xmrig::IWorker *xmrig::Workers<T>::create(Thread<T> *)
std::shared_ptr<xmrig::IWorker> xmrig::Workers<T>::create(Thread<T> *)
{
return nullptr;
}
@ -177,22 +166,21 @@ void *xmrig::Workers<T>::onReady(void *arg)
{
auto handle = static_cast<Thread<T>* >(arg);
IWorker *worker = create(handle);
assert(worker != nullptr);
std::shared_ptr<IWorker> worker = create(handle);
assert(worker);
if (!worker || !worker->selfTest()) {
LOG_ERR("%s " RED("thread ") RED_BOLD("#%zu") RED(" self-test failed"), T::tag(), worker ? worker->id() : 0);
handle->backend()->start(worker, false);
delete worker;
worker.reset();
handle->backend()->start(worker.get(), false);
return nullptr;
}
assert(handle->backend() != nullptr);
handle->setWorker(worker);
handle->backend()->start(worker, true);
handle->backend()->start(worker.get(), true);
return nullptr;
}
@ -202,7 +190,7 @@ template<class T>
void xmrig::Workers<T>::start(const std::vector<T> &data, bool /*sleep*/)
{
for (const auto &item : data) {
m_workers.push_back(new Thread<T>(d_ptr->backend, m_workers.size(), item));
m_workers.emplace_back(std::make_shared<Thread<T>>(d_ptr->backend, m_workers.size(), item));
}
d_ptr->hashrate = std::make_shared<Hashrate>(m_workers.size());
@ -211,7 +199,7 @@ void xmrig::Workers<T>::start(const std::vector<T> &data, bool /*sleep*/)
Nonce::touch(T::backend());
# endif
for (auto worker : m_workers) {
for (auto& worker : m_workers) {
worker->start(Workers<T>::onReady);
}
}
@ -221,34 +209,34 @@ namespace xmrig {
template<>
xmrig::IWorker *xmrig::Workers<CpuLaunchData>::create(Thread<CpuLaunchData> *handle)
std::shared_ptr<xmrig::IWorker> Workers<CpuLaunchData>::create(Thread<CpuLaunchData> *handle)
{
# ifdef XMRIG_MINER_PROJECT
switch (handle->config().intensity) {
case 1:
return new CpuWorker<1>(handle->id(), handle->config());
return std::make_shared<CpuWorker<1>>(handle->id(), handle->config());
case 2:
return new CpuWorker<2>(handle->id(), handle->config());
return std::make_shared<CpuWorker<2>>(handle->id(), handle->config());
case 3:
return new CpuWorker<3>(handle->id(), handle->config());
return std::make_shared<CpuWorker<3>>(handle->id(), handle->config());
case 4:
return new CpuWorker<4>(handle->id(), handle->config());
return std::make_shared<CpuWorker<4>>(handle->id(), handle->config());
case 5:
return new CpuWorker<5>(handle->id(), handle->config());
return std::make_shared<CpuWorker<5>>(handle->id(), handle->config());
case 8:
return new CpuWorker<8>(handle->id(), handle->config());
return std::make_shared<CpuWorker<8>>(handle->id(), handle->config());
}
return nullptr;
# else
assert(handle->config().intensity == 1);
return new CpuWorker<1>(handle->id(), handle->config());
return std::make_shared<CpuWorker<1>>(handle->id(), handle->config());
# endif
}
@ -258,9 +246,9 @@ template class Workers<CpuLaunchData>;
#ifdef XMRIG_FEATURE_OPENCL
template<>
xmrig::IWorker *xmrig::Workers<OclLaunchData>::create(Thread<OclLaunchData> *handle)
std::shared_ptr<xmrig::IWorker> Workers<OclLaunchData>::create(Thread<OclLaunchData> *handle)
{
return new OclWorker(handle->id(), handle->config());
return std::make_shared<OclWorker>(handle->id(), handle->config());
}
@ -270,9 +258,9 @@ template class Workers<OclLaunchData>;
#ifdef XMRIG_FEATURE_CUDA
template<>
xmrig::IWorker *xmrig::Workers<CudaLaunchData>::create(Thread<CudaLaunchData> *handle)
std::shared_ptr<xmrig::IWorker> Workers<CudaLaunchData>::create(Thread<CudaLaunchData> *handle)
{
return new CudaWorker(handle->id(), handle->config());
return std::make_shared<CudaWorker>(handle->id(), handle->config());
}

15
src/backend/common/Workers.h
View file

@ -52,7 +52,6 @@ public:
XMRIG_DISABLE_COPY_MOVE(Workers)
Workers();
~Workers();
inline void start(const std::vector<T> &data) { start(data, true); }
@ -67,20 +66,20 @@ public:
# endif
private:
static IWorker *create(Thread<T> *handle);
static std::shared_ptr<IWorker> create(Thread<T> *handle);
static void *onReady(void *arg);
void start(const std::vector<T> &data, bool sleep);
std::vector<Thread<T> *> m_workers;
WorkersPrivate *d_ptr;
std::vector<std::shared_ptr<Thread<T>>> m_workers;
std::shared_ptr<WorkersPrivate> d_ptr;
};
template<class T>
void xmrig::Workers<T>::jobEarlyNotification(const Job &job)
{
for (Thread<T>* t : m_workers) {
for (auto& t : m_workers) {
if (t->worker()) {
t->worker()->jobEarlyNotification(job);
}
@ -89,20 +88,20 @@ void xmrig::Workers<T>::jobEarlyNotification(const Job &job)
template<>
IWorker *Workers<CpuLaunchData>::create(Thread<CpuLaunchData> *handle);
std::shared_ptr<IWorker> Workers<CpuLaunchData>::create(Thread<CpuLaunchData> *handle);
extern template class Workers<CpuLaunchData>;
#ifdef XMRIG_FEATURE_OPENCL
template<>
IWorker *Workers<OclLaunchData>::create(Thread<OclLaunchData> *handle);
std::shared_ptr<IWorker> Workers<OclLaunchData>::create(Thread<OclLaunchData> *handle);
extern template class Workers<OclLaunchData>;
#endif
#ifdef XMRIG_FEATURE_CUDA
template<>
IWorker *Workers<CudaLaunchData>::create(Thread<CudaLaunchData> *handle);
std::shared_ptr<IWorker> Workers<CudaLaunchData>::create(Thread<CudaLaunchData> *handle);
extern template class Workers<CudaLaunchData>;
#endif

15
src/backend/common/benchmark/BenchState.cpp
View file

@ -51,7 +51,7 @@ public:
};
static BenchStatePrivate *d_ptr = nullptr;
static std::shared_ptr<BenchStatePrivate> d_ptr;
std::atomic<uint64_t> BenchState::m_data{};
@ -61,7 +61,7 @@ std::atomic<uint64_t> BenchState::m_data{};
bool xmrig::BenchState::isDone()
{
return d_ptr == nullptr;
return !d_ptr;
}
@ -105,14 +105,13 @@ uint64_t xmrig::BenchState::start(size_t threads, const IBackend *backend)
void xmrig::BenchState::destroy()
{
delete d_ptr;
d_ptr = nullptr;
d_ptr.reset();
}
void xmrig::BenchState::done()
{
assert(d_ptr != nullptr && d_ptr->async && d_ptr->remaining > 0);
assert(d_ptr && d_ptr->async && d_ptr->remaining > 0);
const uint64_t ts = Chrono::steadyMSecs();
@ -129,15 +128,15 @@ void xmrig::BenchState::done()
void xmrig::BenchState::init(IBenchListener *listener, uint32_t size)
{
assert(d_ptr == nullptr);
assert(!d_ptr);
d_ptr = new BenchStatePrivate(listener, size);
d_ptr = std::make_shared<BenchStatePrivate>(listener, size);
}
void xmrig::BenchState::setSize(uint32_t size)
{
assert(d_ptr != nullptr);
assert(d_ptr);
d_ptr->size = size;
}

13
src/backend/cpu/Cpu.cpp
View file

@ -31,20 +31,20 @@
#endif
static xmrig::ICpuInfo *cpuInfo = nullptr;
static std::shared_ptr<xmrig::ICpuInfo> cpuInfo;
xmrig::ICpuInfo *xmrig::Cpu::info()
{
if (cpuInfo == nullptr) {
if (!cpuInfo) {
# if defined(XMRIG_FEATURE_HWLOC)
cpuInfo = new HwlocCpuInfo();
cpuInfo = std::make_shared<HwlocCpuInfo>();
# else
cpuInfo = new BasicCpuInfo();
cpuInfo = std::make_shared<BasicCpuInfo>();
# endif
}
return cpuInfo;
return cpuInfo.get();
}
@ -56,6 +56,5 @@ rapidjson::Value xmrig::Cpu::toJSON(rapidjson::Document &doc)
void xmrig::Cpu::release()
{
delete cpuInfo;
cpuInfo = nullptr;
cpuInfo.reset();
}

3
src/backend/cpu/CpuBackend.cpp
View file

@ -242,7 +242,7 @@ const char *xmrig::cpu_tag()
xmrig::CpuBackend::CpuBackend(Controller *controller) :
d_ptr(new CpuBackendPrivate(controller))
d_ptr(std::make_shared<CpuBackendPrivate>(controller))
{
d_ptr->workers.setBackend(this);
}
@ -250,7 +250,6 @@ xmrig::CpuBackend::CpuBackend(Controller *controller) :
xmrig::CpuBackend::~CpuBackend()
{
delete d_ptr;
}

2
src/backend/cpu/CpuBackend.h
View file

@ -70,7 +70,7 @@ protected:
# endif
private:
CpuBackendPrivate *d_ptr;
std::shared_ptr<CpuBackendPrivate> d_ptr;
};

16
src/backend/cpu/CpuWorker.cpp
View file

@ -57,7 +57,7 @@ static constexpr uint32_t kReserveCount = 32768;
#ifdef XMRIG_ALGO_CN_HEAVY
static std::mutex cn_heavyZen3MemoryMutex;
VirtualMemory* cn_heavyZen3Memory = nullptr;
std::shared_ptr<VirtualMemory> cn_heavyZen3Memory;
#endif
} // namespace xmrig
@ -87,14 +87,14 @@ xmrig::CpuWorker<N>::CpuWorker(size_t id, const CpuLaunchData &data) :
if (!cn_heavyZen3Memory) {
// Round up number of threads to the multiple of 8
const size_t num_threads = ((m_threads + 7) / 8) * 8;
cn_heavyZen3Memory = new VirtualMemory(m_algorithm.l3() * num_threads, data.hugePages, false, false, node());
cn_heavyZen3Memory = std::make_shared<VirtualMemory>(m_algorithm.l3() * num_threads, data.hugePages, false, false, node());
}
m_memory = cn_heavyZen3Memory;
}
else
# endif
{
m_memory = new VirtualMemory(m_algorithm.l3() * N, data.hugePages, false, true, node());
m_memory = std::make_shared<VirtualMemory>(m_algorithm.l3() * N, data.hugePages, false, true, node());
}
# ifdef XMRIG_ALGO_GHOSTRIDER
@ -107,7 +107,7 @@ template<size_t N>
xmrig::CpuWorker<N>::~CpuWorker()
{
# ifdef XMRIG_ALGO_RANDOMX
RxVm::destroy(m_vm);
m_vm.reset();
# endif
CnCtx::release(m_ctx, N);
@ -116,7 +116,7 @@ xmrig::CpuWorker<N>::~CpuWorker()
if (m_memory != cn_heavyZen3Memory)
# endif
{
delete m_memory;
m_memory.reset();
}
# ifdef XMRIG_ALGO_GHOSTRIDER
@ -148,7 +148,7 @@ void xmrig::CpuWorker<N>::allocateRandomX_VM()
}
else if (!dataset->get() && (m_job.currentJob().seed() != m_seed)) {
// Update RandomX light VM with the new seed
randomx_vm_set_cache(m_vm, dataset->cache()->get());
randomx_vm_set_cache(m_vm.get(), dataset->cache()->get());
}
m_seed = m_job.currentJob().seed();
}
@ -296,7 +296,7 @@ void xmrig::CpuWorker<N>::start()
if (job.hasMinerSignature()) {
job.generateMinerSignature(m_job.blob(), job.size(), miner_signature_ptr);
}
randomx_calculate_hash_first(m_vm, tempHash, m_job.blob(), job.size());
randomx_calculate_hash_first(m_vm.get(), tempHash, m_job.blob(), job.size());
}
if (!nextRound()) {
@ -307,7 +307,7 @@ void xmrig::CpuWorker<N>::start()
memcpy(miner_signature_saved, miner_signature_ptr, sizeof(miner_signature_saved));
job.generateMinerSignature(m_job.blob(), job.size(), miner_signature_ptr);
}
randomx_calculate_hash_next(m_vm, tempHash, m_job.blob(), job.size(), m_hash);
randomx_calculate_hash_next(m_vm.get(), tempHash, m_job.blob(), job.size(), m_hash);
}
else
# endif

6
src/backend/cpu/CpuWorker.h
View file

@ -66,7 +66,7 @@ protected:
void hashrateData(uint64_t &hashCount, uint64_t &timeStamp, uint64_t &rawHashes) const override;
void start() override;
inline const VirtualMemory *memory() const override { return m_memory; }
inline const VirtualMemory* memory() const override { return m_memory.get(); }
inline size_t intensity() const override { return N; }
inline void jobEarlyNotification(const Job&) override {}
@ -92,11 +92,11 @@ private:
const Miner *m_miner;
const size_t m_threads;
cryptonight_ctx *m_ctx[N];
VirtualMemory *m_memory = nullptr;
std::shared_ptr<VirtualMemory> m_memory;
WorkerJob<N> m_job;
# ifdef XMRIG_ALGO_RANDOMX
randomx_vm *m_vm = nullptr;
std::shared_ptr<randomx_vm> m_vm;
Buffer m_seed;
# endif

4
src/backend/opencl/OclBackend.cpp
View file

@ -283,7 +283,7 @@ const char *xmrig::ocl_tag()
xmrig::OclBackend::OclBackend(Controller *controller) :
d_ptr(new OclBackendPrivate(controller))
d_ptr(std::make_shared<OclBackendPrivate>(controller))
{
d_ptr->workers.setBackend(this);
}
@ -291,7 +291,7 @@ xmrig::OclBackend::OclBackend(Controller *controller) :
xmrig::OclBackend::~OclBackend()
{
delete d_ptr;
d_ptr.reset();
OclLib::close();

2
src/backend/opencl/OclBackend.h
View file

@ -70,7 +70,7 @@ protected:
# endif
private:
OclBackendPrivate *d_ptr;
std::shared_ptr<OclBackendPrivate> d_ptr;
};

8
src/base/api/Api.cpp
View file

@ -95,8 +95,7 @@ xmrig::Api::~Api()
# ifdef XMRIG_FEATURE_HTTP
if (m_httpd) {
m_httpd->stop();
delete m_httpd;
m_httpd = nullptr; // Ensure the pointer is set to nullptr after deletion
m_httpd.reset();
}
# endif
}
@ -116,12 +115,11 @@ void xmrig::Api::start()
# ifdef XMRIG_FEATURE_HTTP
if (!m_httpd) {
m_httpd = new Httpd(m_base);
m_httpd = std::make_shared<Httpd>(m_base);
if (!m_httpd->start()) {
LOG_ERR("%s " RED_BOLD("HTTP API server failed to start."), Tags::network());
delete m_httpd; // Properly handle failure to start
m_httpd = nullptr;
m_httpd.reset();
}
}
# endif

2
src/base/api/Api.h
View file

@ -66,7 +66,7 @@ private:
Base *m_base;
char m_id[32]{};
const uint64_t m_timestamp;
Httpd *m_httpd = nullptr;
std::shared_ptr<Httpd> m_httpd;
std::vector<IApiListener *> m_listeners;
String m_workerId;
uint8_t m_ticks = 0;

9
src/base/api/Httpd.cpp
View file

@ -69,13 +69,13 @@ bool xmrig::Httpd::start()
bool tls = false;
# ifdef XMRIG_FEATURE_TLS
m_http = new HttpsServer(m_httpListener);
m_http = std::make_shared<HttpsServer>(m_httpListener);
tls = m_http->setTls(m_base->config()->tls());
# else
m_http = new HttpServer(m_httpListener);
m_http = std::make_shared<HttpServer>(m_httpListener);
# endif
m_server = new TcpServer(config.host(), config.port(), m_http);
m_server = std::make_shared<TcpServer>(config.host(), config.port(), m_http.get());
const int rc = m_server->bind();
Log::print(GREEN_BOLD(" * ") WHITE_BOLD("%-13s") CSI "1;%dm%s:%d" " " RED_BOLD("%s"),
@ -112,9 +112,6 @@ bool xmrig::Httpd::start()
void xmrig::Httpd::stop()
{
delete m_server;
delete m_http;
m_server = nullptr;
m_http = nullptr;
m_port = 0;

6
src/base/api/Httpd.h
View file

@ -55,13 +55,13 @@ private:
const Base *m_base;
std::shared_ptr<IHttpListener> m_httpListener;
TcpServer *m_server = nullptr;
std::shared_ptr<TcpServer> m_server;
uint16_t m_port = 0;
# ifdef XMRIG_FEATURE_TLS
HttpsServer *m_http = nullptr;
std::shared_ptr<HttpsServer> m_http;
# else
HttpServer *m_http = nullptr;
std::shared_ptr<HttpServer> m_http;
# endif
};

4
src/base/io/Async.cpp
View file

@ -128,7 +128,7 @@ public:
} // namespace xmrig
xmrig::Async::Async(Callback callback) : d_ptr(new AsyncPrivate())
xmrig::Async::Async(Callback callback) : d_ptr(std::make_shared<AsyncPrivate>())
{
d_ptr->callback = std::move(callback);
d_ptr->async = new uv_async_t;
@ -151,8 +151,6 @@ xmrig::Async::Async(IAsyncListener *listener) : d_ptr(new AsyncPrivate())
xmrig::Async::~Async()
{
Handle::close(d_ptr->async);
delete d_ptr;
}

2
src/base/io/Async.h
View file

@ -49,7 +49,7 @@ public:
void send();
private:
AsyncPrivate *d_ptr;
std::shared_ptr<AsyncPrivate> d_ptr;
};

4
src/base/io/Watcher.cpp
View file

@ -36,7 +36,7 @@ xmrig::Watcher::Watcher(const String &path, IWatcherListener *listener) :
m_listener(listener),
m_path(path)
{
m_timer = new Timer(this);
m_timer = std::make_shared<Timer>(this);
m_fsEvent = new uv_fs_event_t;
m_fsEvent->data = this;
@ -48,8 +48,6 @@ xmrig::Watcher::Watcher(const String &path, IWatcherListener *listener) :
xmrig::Watcher::~Watcher()
{
delete m_timer;
Handle::close(m_fsEvent);
}

2
src/base/io/Watcher.h
View file

@ -60,7 +60,7 @@ private:
IWatcherListener *m_listener;
String m_path;
Timer *m_timer;
std::shared_ptr<Timer> m_timer;
uv_fs_event_t *m_fsEvent;
};

24
src/base/io/log/Log.cpp
View file

@ -66,17 +66,10 @@ public:
LogPrivate() = default;
~LogPrivate() = default;
inline ~LogPrivate()
{
for (auto backend : m_backends) {
delete backend;
}
}
inline void add(ILogBackend *backend) { m_backends.push_back(backend); }
inline void add(std::shared_ptr<ILogBackend> backend) { m_backends.emplace_back(backend); }
void print(Log::Level level, const char *fmt, va_list args)
@ -108,7 +101,7 @@ public:
}
if (!m_backends.empty()) {
for (auto backend : m_backends) {
for (auto& backend : m_backends) {
backend->print(ts, level, m_buf, offset, size, true);
backend->print(ts, level, txt.c_str(), offset ? (offset - 11) : 0, txt.size(), false);
}
@ -188,13 +181,13 @@ private:
char m_buf[Log::kMaxBufferSize]{};
std::mutex m_mutex;
std::vector<ILogBackend*> m_backends;
std::vector<std::shared_ptr<ILogBackend>> m_backends;
};
bool Log::m_background = false;
bool Log::m_colors = true;
LogPrivate *Log::d = nullptr;
std::shared_ptr<LogPrivate> Log::d{};
uint32_t Log::m_verbose = 0;
@ -202,7 +195,7 @@ uint32_t Log::m_verbose = 0;
void xmrig::Log::add(ILogBackend *backend)
void xmrig::Log::add(std::shared_ptr<ILogBackend> backend)
{
assert(d != nullptr);
@ -214,14 +207,13 @@ void xmrig::Log::add(ILogBackend *backend)
void xmrig::Log::destroy()
{
delete d;
d = nullptr;
d.reset();
}
void xmrig::Log::init()
{
d = new LogPrivate();
d = std::make_shared<LogPrivate>();
}

5
src/base/io/log/Log.h
View file

@ -23,6 +23,7 @@
#include <cstddef>
#include <cstdint>
#include <memory>
namespace xmrig {
@ -49,7 +50,7 @@ public:
constexpr static size_t kMaxBufferSize = 16384;
static void add(ILogBackend *backend);
static void add(std::shared_ptr<ILogBackend> backend);
static void destroy();
static void init();
static void print(const char *fmt, ...);
@ -66,7 +67,7 @@ public:
private:
static bool m_background;
static bool m_colors;
static LogPrivate *d;
static std::shared_ptr<LogPrivate> d;
static uint32_t m_verbose;
};

65
src/base/kernel/Base.cpp
View file

@ -80,11 +80,10 @@ public:
inline ~BasePrivate()
{
# ifdef XMRIG_FEATURE_API
delete api;
api.reset();
# endif
delete config;
delete watcher;
watcher.reset();
NetBuffer::destroy();
}
@ -98,27 +97,25 @@ public:
}
inline void replace(Config *newConfig)
inline void replace(std::shared_ptr<Config> newConfig)
{
Config *previousConfig = config;
auto previousConfig = config;
config = newConfig;
for (IBaseListener *listener : listeners) {
listener->onConfigChanged(config, previousConfig);
listener->onConfigChanged(config.get(), previousConfig.get());
}
delete previousConfig;
}
Api *api = nullptr;
Config *config = nullptr;
std::shared_ptr<Api> api;
std::shared_ptr<Config> config;
std::vector<IBaseListener *> listeners;
Watcher *watcher = nullptr;
std::shared_ptr<Watcher> watcher;
private:
inline static Config *load(Process *process)
inline static std::shared_ptr<Config> load(Process *process)
{
JsonChain chain;
ConfigTransform transform;
@ -127,29 +124,29 @@ private:
ConfigTransform::load(chain, process, transform);
if (read(chain, config)) {
return config.release();
return config;
}
chain.addFile(Process::location(Process::DataLocation, "config.json"));
if (read(chain, config)) {
return config.release();
return config;
}
chain.addFile(Process::location(Process::HomeLocation, "." APP_ID ".json"));
if (read(chain, config)) {
return config.release();
return config;
}
chain.addFile(Process::location(Process::HomeLocation, ".config" XMRIG_DIR_SEPARATOR APP_ID ".json"));
if (read(chain, config)) {
return config.release();
return config;
}
# ifdef XMRIG_FEATURE_EMBEDDED_CONFIG
chain.addRaw(default_config);
if (read(chain, config)) {
return config.release();
return config;
}
# endif
@ -162,7 +159,7 @@ private:
xmrig::Base::Base(Process *process)
: d_ptr(new BasePrivate(process))
: d_ptr(std::make_shared<BasePrivate>(process))
{
}
@ -170,7 +167,6 @@ xmrig::Base::Base(Process *process)
xmrig::Base::~Base()
{
delete d_ptr;
}
@ -183,7 +179,7 @@ bool xmrig::Base::isReady() const
int xmrig::Base::init()
{
# ifdef XMRIG_FEATURE_API
d_ptr->api = new Api(this);
d_ptr->api = std::make_shared<Api>(this);
d_ptr->api->addListener(this);
# endif
@ -193,16 +189,16 @@ int xmrig::Base::init()
Log::setBackground(true);
}
else {
Log::add(new ConsoleLog(config()->title()));
Log::add(std::make_shared<ConsoleLog>(config()->title()));
}
if (config()->logFile()) {
Log::add(new FileLog(config()->logFile()));
Log::add(std::make_shared<FileLog>(config()->logFile()));
}
# ifdef HAVE_SYSLOG_H
if (config()->isSyslog()) {
Log::add(new SysLog());
Log::add(std::make_shared<SysLog>());
}
# endif
@ -221,7 +217,7 @@ void xmrig::Base::start()
}
if (config()->isWatch()) {
d_ptr->watcher = new Watcher(config()->fileName(), this);
d_ptr->watcher = std::make_shared<Watcher>(config()->fileName(), this);
}
}
@ -232,8 +228,7 @@ void xmrig::Base::stop()
api()->stop();
# endif
delete d_ptr->watcher;
d_ptr->watcher = nullptr;
d_ptr->watcher.reset();
}
@ -241,7 +236,7 @@ xmrig::Api *xmrig::Base::api() const
{
assert(d_ptr->api != nullptr);
return d_ptr->api;
return d_ptr->api.get();
}
@ -258,18 +253,14 @@ bool xmrig::Base::reload(const rapidjson::Value &json)
return false;
}
auto config = new Config();
auto config = std::make_shared<Config>();
if (!config->read(reader, d_ptr->config->fileName())) {
delete config;
return false;
}
const bool saved = config->save();
if (config->isWatch() && d_ptr->watcher && saved) {
delete config;
return true;
}
@ -279,11 +270,11 @@ bool xmrig::Base::reload(const rapidjson::Value &json)
}
xmrig::Config *xmrig::Base::config() const
xmrig::Config* xmrig::Base::config() const
{
assert(d_ptr->config != nullptr);
assert(d_ptr->config);
return d_ptr->config;
return d_ptr->config.get();
}
@ -300,12 +291,10 @@ void xmrig::Base::onFileChanged(const String &fileName)
JsonChain chain;
chain.addFile(fileName);
auto config = new Config();
auto config = std::make_shared<Config>();
if (!config->read(chain, chain.fileName())) {
LOG_ERR("%s " RED("reloading failed"), Tags::config());
delete config;
return;
}

2
src/base/kernel/Base.h
View file

@ -64,7 +64,7 @@ protected:
# endif
private:
BasePrivate *d_ptr;
std::shared_ptr<BasePrivate> d_ptr;
};

9
src/base/net/dns/DnsUvBackend.cpp
View file

@ -29,13 +29,13 @@
namespace xmrig {
static Storage<DnsUvBackend> *storage = nullptr;
static std::shared_ptr<Storage<DnsUvBackend>> storage = nullptr;
Storage<DnsUvBackend> &DnsUvBackend::getStorage()
{
if (storage == nullptr) {
storage = new Storage<DnsUvBackend>();
if (!storage) {
storage = std::make_shared<Storage<DnsUvBackend>>();
}
return *storage;
@ -67,8 +67,7 @@ xmrig::DnsUvBackend::~DnsUvBackend()
storage->release(m_key);
if (storage->isEmpty()) {
delete storage;
storage = nullptr;
storage.reset();
}
}

6
src/base/net/stratum/DaemonClient.cpp
View file

@ -87,14 +87,13 @@ xmrig::DaemonClient::DaemonClient(int id, IClientListener *listener) :
BaseClient(id, listener)
{
m_httpListener = std::make_shared<HttpListener>(this);
m_timer = new Timer(this);
m_timer = std::make_shared<Timer>(this);
m_key = m_storage.add(this);
}
xmrig::DaemonClient::~DaemonClient()
{
delete m_timer;
delete m_ZMQSocket;
}
@ -104,9 +103,6 @@ void xmrig::DaemonClient::deleteLater()
if (m_pool.zmq_port() >= 0) {
ZMQClose(true);
}
else {
delete this;
}
}

2
src/base/net/stratum/DaemonClient.h
View file

@ -107,7 +107,7 @@ private:
uint64_t m_jobSteadyMs = 0;
String m_tlsFingerprint;
String m_tlsVersion;
Timer *m_timer;
std::shared_ptr<Timer> m_timer;
uint64_t m_blocktemplateRequestHeight = 0;
WalletAddress m_walletAddress;

18
src/base/net/stratum/Pool.cpp
View file

@ -221,42 +221,42 @@ bool xmrig::Pool::isEqual(const Pool &other) const
}
xmrig::IClient *xmrig::Pool::createClient(int id, IClientListener *listener) const
std::shared_ptr<xmrig::IClient> xmrig::Pool::createClient(int id, IClientListener* listener) const
{
IClient *client = nullptr;
std::shared_ptr<xmrig::IClient> client;
if (m_mode == MODE_POOL) {
# if defined XMRIG_ALGO_KAWPOW || defined XMRIG_ALGO_GHOSTRIDER
const uint32_t f = m_algorithm.family();
if ((f == Algorithm::KAWPOW) || (f == Algorithm::GHOSTRIDER) || (m_coin == Coin::RAVEN)) {
client = new EthStratumClient(id, Platform::userAgent(), listener);
client = std::make_shared<EthStratumClient>(id, Platform::userAgent(), listener);
}
else
# endif
{
client = new Client(id, Platform::userAgent(), listener);
client = std::make_shared<Client>(id, Platform::userAgent(), listener);
}
}
# ifdef XMRIG_FEATURE_HTTP
else if (m_mode == MODE_DAEMON) {
client = new DaemonClient(id, listener);
client = std::make_shared<DaemonClient>(id, listener);
}
else if (m_mode == MODE_SELF_SELECT) {
client = new SelfSelectClient(id, Platform::userAgent(), listener, m_submitToOrigin);
client = std::make_shared<SelfSelectClient>(id, Platform::userAgent(), listener, m_submitToOrigin);
}
# endif
# if defined XMRIG_ALGO_KAWPOW || defined XMRIG_ALGO_GHOSTRIDER
else if (m_mode == MODE_AUTO_ETH) {
client = new AutoClient(id, Platform::userAgent(), listener);
client = std::make_shared<AutoClient>(id, Platform::userAgent(), listener);
}
# endif
# ifdef XMRIG_FEATURE_BENCHMARK
else if (m_mode == MODE_BENCHMARK) {
client = new BenchClient(m_benchmark, listener);
client = std::make_shared<BenchClient>(m_benchmark, listener);
}
# endif
assert(client != nullptr);
assert(client);
if (client) {
client->setPool(*this);

2
src/base/net/stratum/Pool.h
View file

@ -127,7 +127,7 @@ public:
bool isEnabled() const;
bool isEqual(const Pool &other) const;
IClient *createClient(int id, IClientListener *listener) const;
std::shared_ptr<IClient> createClient(int id, IClientListener *listener) const;
rapidjson::Value toJSON(rapidjson::Document &doc) const;
std::string printableName() const;

8
src/base/net/stratum/Pools.cpp
View file

@ -80,17 +80,17 @@ int xmrig::Pools::donateLevel() const
}
xmrig::IStrategy *xmrig::Pools::createStrategy(IStrategyListener *listener) const
std::shared_ptr<xmrig::IStrategy> xmrig::Pools::createStrategy(IStrategyListener *listener) const
{
if (active() == 1) {
for (const Pool &pool : m_data) {
if (pool.isEnabled()) {
return new SinglePoolStrategy(pool, retryPause(), retries(), listener);
return std::make_shared<SinglePoolStrategy>(pool, retryPause(), retries(), listener);
}
}
}
auto strategy = new FailoverStrategy(retryPause(), retries(), listener);
auto strategy = std::make_shared<FailoverStrategy>(retryPause(), retries(), listener);
for (const Pool &pool : m_data) {
if (pool.isEnabled()) {
strategy->add(pool);
@ -154,7 +154,7 @@ void xmrig::Pools::load(const IJsonReader &reader)
Pool pool(value);
if (pool.isValid()) {
m_data.push_back(std::move(pool));
m_data.emplace_back(std::move(pool));
}
}

2
src/base/net/stratum/Pools.h
View file

@ -73,7 +73,7 @@ public:
bool isEqual(const Pools &other) const;
int donateLevel() const;
IStrategy *createStrategy(IStrategyListener *listener) const;
std::shared_ptr<IStrategy> createStrategy(IStrategyListener *listener) const;
rapidjson::Value toJSON(rapidjson::Document &doc) const;
size_t active() const;
uint32_t benchSize() const;

3
src/base/net/stratum/SelfSelectClient.cpp
View file

@ -56,13 +56,12 @@ xmrig::SelfSelectClient::SelfSelectClient(int id, const char *agent, IClientList
m_listener(listener)
{
m_httpListener = std::make_shared<HttpListener>(this);
m_client = new Client(id, agent, this);
m_client = std::make_shared<Client>(id, agent, this);
}
xmrig::SelfSelectClient::~SelfSelectClient()
{
delete m_client;
}

2
src/base/net/stratum/SelfSelectClient.h
View file

@ -105,7 +105,7 @@ private:
bool m_active = false;
bool m_quiet = false;
const bool m_submitToOrigin;
IClient *m_client;
std::shared_ptr<IClient> m_client;
IClientListener *m_listener;
int m_retries = 5;
int64_t m_failures = 0;

2
src/base/net/stratum/benchmark/BenchClient.h
View file

@ -53,7 +53,7 @@ public:
inline int64_t sequence() const override { return 0; }
inline int64_t submit(const JobResult &) override { return 0; }
inline void connect(const Pool &pool) override { setPool(pool); }
inline void deleteLater() override { delete this; }
inline void deleteLater() override {}
inline void setAlgo(const Algorithm &algo) override {}
inline void setEnabled(bool enabled) override {}
inline void setProxy(const ProxyUrl &proxy) override {}

12
src/base/net/stratum/strategies/FailoverStrategy.cpp
View file

@ -47,7 +47,7 @@ xmrig::FailoverStrategy::FailoverStrategy(int retryPause, int retries, IStrategy
xmrig::FailoverStrategy::~FailoverStrategy()
{
for (IClient *client : m_pools) {
for (auto& client : m_pools) {
client->deleteLater();
}
}
@ -55,7 +55,7 @@ xmrig::FailoverStrategy::~FailoverStrategy()
void xmrig::FailoverStrategy::add(const Pool &pool)
{
IClient *client = pool.createClient(static_cast<int>(m_pools.size()), this);
std::shared_ptr<IClient> client = pool.createClient(static_cast<int>(m_pools.size()), this);
client->setRetries(m_retries);
client->setRetryPause(m_retryPause * 1000);
@ -93,7 +93,7 @@ void xmrig::FailoverStrategy::resume()
void xmrig::FailoverStrategy::setAlgo(const Algorithm &algo)
{
for (IClient *client : m_pools) {
for (auto& client : m_pools) {
client->setAlgo(algo);
}
}
@ -101,7 +101,7 @@ void xmrig::FailoverStrategy::setAlgo(const Algorithm &algo)
void xmrig::FailoverStrategy::setProxy(const ProxyUrl &proxy)
{
for (IClient *client : m_pools) {
for (auto& client : m_pools) {
client->setProxy(proxy);
}
}
@ -109,7 +109,7 @@ void xmrig::FailoverStrategy::setProxy(const ProxyUrl &proxy)
void xmrig::FailoverStrategy::stop()
{
for (auto &pool : m_pools) {
for (auto& pool : m_pools) {
pool->disconnect();
}
@ -122,7 +122,7 @@ void xmrig::FailoverStrategy::stop()
void xmrig::FailoverStrategy::tick(uint64_t now)
{
for (IClient *client : m_pools) {
for (auto& client : m_pools) {
client->tick(now);
}
}

6
src/base/net/stratum/strategies/FailoverStrategy.h
View file

@ -49,7 +49,7 @@ public:
protected:
inline bool isActive() const override { return m_active >= 0; }
inline IClient *client() const override { return isActive() ? active() : m_pools[m_index]; }
inline IClient* client() const override { return isActive() ? active() : m_pools[m_index].get(); }
int64_t submit(const JobResult &result) override;
void connect() override;
@ -67,7 +67,7 @@ protected:
void onVerifyAlgorithm(const IClient *client, const Algorithm &algorithm, bool *ok) override;
private:
inline IClient *active() const { return m_pools[static_cast<size_t>(m_active)]; }
inline IClient* active() const { return m_pools[static_cast<size_t>(m_active)].get(); }
const bool m_quiet;
const int m_retries;
@ -75,7 +75,7 @@ private:
int m_active = -1;
IStrategyListener *m_listener;
size_t m_index = 0;
std::vector<IClient*> m_pools;
std::vector<std::shared_ptr<IClient>> m_pools;
};

2
src/base/net/stratum/strategies/SinglePoolStrategy.cpp
View file

@ -66,7 +66,7 @@ void xmrig::SinglePoolStrategy::resume()
return;
}
m_listener->onJob(this, m_client, m_client->job(), rapidjson::Value(rapidjson::kNullType));
m_listener->onJob(this, m_client.get(), m_client->job(), rapidjson::Value(rapidjson::kNullType));
}

4
src/base/net/stratum/strategies/SinglePoolStrategy.h
View file

@ -49,7 +49,7 @@ public:
protected:
inline bool isActive() const override { return m_active; }
inline IClient *client() const override { return m_client; }
inline IClient* client() const override { return m_client.get(); }
int64_t submit(const JobResult &result) override;
void connect() override;
@ -68,7 +68,7 @@ protected:
private:
bool m_active;
IClient *m_client;
std::shared_ptr<IClient> m_client;
IStrategyListener *m_listener;
};

10
src/base/net/tools/NetBuffer.cpp
View file

@ -23,22 +23,23 @@
#include <cassert>
#include <memory>
#include <uv.h>
namespace xmrig {
static MemPool<XMRIG_NET_BUFFER_CHUNK_SIZE, XMRIG_NET_BUFFER_INIT_CHUNKS> *pool = nullptr;
static std::shared_ptr<MemPool<XMRIG_NET_BUFFER_CHUNK_SIZE, XMRIG_NET_BUFFER_INIT_CHUNKS>> pool;
inline MemPool<XMRIG_NET_BUFFER_CHUNK_SIZE, XMRIG_NET_BUFFER_INIT_CHUNKS> *getPool()
{
if (!pool) {
pool = new MemPool<XMRIG_NET_BUFFER_CHUNK_SIZE, XMRIG_NET_BUFFER_INIT_CHUNKS>();
pool = std::make_shared<MemPool<XMRIG_NET_BUFFER_CHUNK_SIZE, XMRIG_NET_BUFFER_INIT_CHUNKS>>();
}
return pool;
return pool.get();
}
@ -59,8 +60,7 @@ void xmrig::NetBuffer::destroy()
assert(pool->freeSize() == pool->size());
delete pool;
pool = nullptr;
pool.reset();
}

46
src/core/Miner.cpp
View file

@ -84,10 +84,10 @@ public:
inline ~MinerPrivate()
{
delete timer;
timer.reset();
for (IBackend *backend : backends) {
delete backend;
for (auto& backend : backends) {
backend.reset();
}
# ifdef XMRIG_ALGO_RANDOMX
@ -98,7 +98,7 @@ public:
bool isEnabled(const Algorithm &algorithm) const
{
for (IBackend *backend : backends) {
for (auto& backend : backends) {
if (backend->isEnabled() && backend->isEnabled(algorithm)) {
return true;
}
@ -124,7 +124,7 @@ public:
Nonce::reset(job.index());
}
for (IBackend *backend : backends) {
for (auto& backend : backends) {
backend->setJob(job);
}
@ -175,7 +175,7 @@ public:
double t[3] = { 0.0 };
for (IBackend *backend : backends) {
for (auto& backend : backends) {
const Hashrate *hr = backend->hashrate();
if (!hr) {
continue;
@ -221,7 +221,7 @@ public:
reply.SetArray();
for (IBackend *backend : backends) {
for (auto& backend : backends) {
reply.PushBack(backend->toJSON(doc), allocator);
}
}
@ -364,9 +364,9 @@ public:
Controller *controller;
Job job;
mutable std::map<Algorithm::Id, double> maxHashrate;
std::vector<IBackend *> backends;
std::vector<std::shared_ptr<IBackend>> backends;
String userJobId;
Timer *timer = nullptr;
std::shared_ptr<Timer> timer;
uint64_t ticks = 0;
Taskbar m_taskbar;
@ -378,7 +378,7 @@ public:
xmrig::Miner::Miner(Controller *controller)
: d_ptr(new MinerPrivate(controller))
: d_ptr(std::make_shared<MinerPrivate>(controller))
{
const int priority = controller->config()->cpu().priority();
if (priority >= 0) {
@ -400,29 +400,23 @@ xmrig::Miner::Miner(Controller *controller)
controller->api()->addListener(this);
# endif
d_ptr->timer = new Timer(this);
d_ptr->timer = std::make_shared<Timer>(this);
d_ptr->backends.reserve(3);
d_ptr->backends.push_back(new CpuBackend(controller));
d_ptr->backends.emplace_back(std::make_shared<CpuBackend>(controller));
# ifdef XMRIG_FEATURE_OPENCL
d_ptr->backends.push_back(new OclBackend(controller));
d_ptr->backends.emplace_back(std::make_shared<OclBackend>(controller));
# endif
# ifdef XMRIG_FEATURE_CUDA
d_ptr->backends.push_back(new CudaBackend(controller));
d_ptr->backends.emplace_back(std::make_shared<CudaBackend>(controller));
# endif
d_ptr->rebuild();
}
xmrig::Miner::~Miner()
{
delete d_ptr;
}
bool xmrig::Miner::isEnabled() const
{
return d_ptr->enabled;
@ -441,7 +435,7 @@ const xmrig::Algorithms &xmrig::Miner::algorithms() const
}
const std::vector<xmrig::IBackend *> &xmrig::Miner::backends() const
const std::vector<std::shared_ptr<xmrig::IBackend>>& xmrig::Miner::backends() const
{
return d_ptr->backends;
}
@ -538,7 +532,7 @@ void xmrig::Miner::setEnabled(bool enabled)
void xmrig::Miner::setJob(const Job &job, bool donate)
{
for (IBackend *backend : d_ptr->backends) {
for (auto& backend : d_ptr->backends) {
backend->prepare(job);
}
@ -606,7 +600,7 @@ void xmrig::Miner::stop()
{
Nonce::stop();
for (IBackend *backend : d_ptr->backends) {
for (auto& backend : d_ptr->backends) {
backend->stop();
}
}
@ -622,7 +616,7 @@ void xmrig::Miner::onConfigChanged(Config *config, Config *previousConfig)
const Job job = this->job();
for (IBackend *backend : d_ptr->backends) {
for (auto& backend : d_ptr->backends) {
backend->setJob(job);
}
}
@ -636,7 +630,7 @@ void xmrig::Miner::onTimer(const Timer *)
bool stopMiner = false;
for (IBackend *backend : d_ptr->backends) {
for (auto& backend : d_ptr->backends) {
if (!backend->tick(d_ptr->ticks)) {
stopMiner = true;
}
@ -718,7 +712,7 @@ void xmrig::Miner::onRequest(IApiRequest &request)
}
}
for (IBackend *backend : d_ptr->backends) {
for (auto& backend : d_ptr->backends) {
backend->handleRequest(request);
}
}

6
src/core/Miner.h
View file

@ -46,12 +46,12 @@ public:
XMRIG_DISABLE_COPY_MOVE_DEFAULT(Miner)
Miner(Controller *controller);
~Miner() override;
~Miner() override = default;
bool isEnabled() const;
bool isEnabled(const Algorithm &algorithm) const;
const Algorithms &algorithms() const;
const std::vector<IBackend *> &backends() const;
const std::vector<std::shared_ptr<IBackend>> &backends() const;
Job job() const;
void execCommand(char command);
void pause();
@ -72,7 +72,7 @@ protected:
# endif
private:
MinerPrivate *d_ptr;
std::shared_ptr<MinerPrivate> d_ptr;
};

3
src/core/Taskbar.cpp
View file

@ -65,14 +65,13 @@ struct TaskbarPrivate
};
Taskbar::Taskbar() : d_ptr(new TaskbarPrivate())
Taskbar::Taskbar() : d_ptr(std::make_shared<TaskbarPrivate>())
{
}
Taskbar::~Taskbar()
{
delete d_ptr;
}

3
src/core/Taskbar.h
View file

@ -19,6 +19,7 @@
#ifndef XMRIG_TASKBAR_H
#define XMRIG_TASKBAR_H
#include <memory>
namespace xmrig {
@ -39,7 +40,7 @@ private:
bool m_active = false;
bool m_enabled = true;
TaskbarPrivate* d_ptr = nullptr;
std::shared_ptr<TaskbarPrivate> d_ptr;
void updateTaskbarColor();
};

3
src/core/config/Config.cpp
View file

@ -115,14 +115,13 @@ public:
xmrig::Config::Config() :
d_ptr(new ConfigPrivate())
d_ptr(std::make_shared<ConfigPrivate>())
{
}
xmrig::Config::~Config()
{
delete d_ptr;
}

2
src/core/config/Config.h
View file

@ -101,7 +101,7 @@ public:
void getJSON(rapidjson::Document &doc) const override;
private:
ConfigPrivate *d_ptr;
std::shared_ptr<ConfigPrivate> d_ptr;
};

8
src/crypto/common/MemoryPool.cpp
View file

@ -49,18 +49,12 @@ xmrig::MemoryPool::MemoryPool(size_t size, bool hugePages, uint32_t node)
constexpr size_t alignment = 1 << 24;
m_memory = new VirtualMemory(size * pageSize + alignment, hugePages, false, false, node);
m_memory = std::make_shared<VirtualMemory>(size * pageSize + alignment, hugePages, false, false, node);
m_alignOffset = (alignment - (((size_t)m_memory->scratchpad()) % alignment)) % alignment;
}
xmrig::MemoryPool::~MemoryPool()
{
delete m_memory;
}
bool xmrig::MemoryPool::isHugePages(uint32_t) const
{
return m_memory && m_memory->isHugePages();

4
src/crypto/common/MemoryPool.h
View file

@ -44,7 +44,7 @@ public:
XMRIG_DISABLE_COPY_MOVE_DEFAULT(MemoryPool)
MemoryPool(size_t size, bool hugePages, uint32_t node = 0);
~MemoryPool() override;
~MemoryPool() override = default;
protected:
bool isHugePages(uint32_t node) const override;
@ -55,7 +55,7 @@ private:
size_t m_refs = 0;
size_t m_offset = 0;
size_t m_alignOffset = 0;
VirtualMemory *m_memory = nullptr;
std::shared_ptr<VirtualMemory> m_memory;
};

15
src/crypto/common/NUMAMemoryPool.cpp
View file

@ -42,14 +42,6 @@ xmrig::NUMAMemoryPool::NUMAMemoryPool(size_t size, bool hugePages) :
}
xmrig::NUMAMemoryPool::~NUMAMemoryPool()
{
for (auto kv : m_map) {
delete kv.second;
}
}
bool xmrig::NUMAMemoryPool::isHugePages(uint32_t node) const
{
if (!m_size) {
@ -81,7 +73,7 @@ void xmrig::NUMAMemoryPool::release(uint32_t node)
xmrig::IMemoryPool *xmrig::NUMAMemoryPool::get(uint32_t node) const
{
return m_map.count(node) ? m_map.at(node) : nullptr;
return m_map.count(node) ? m_map.at(node).get() : nullptr;
}
@ -89,8 +81,9 @@ xmrig::IMemoryPool *xmrig::NUMAMemoryPool::getOrCreate(uint32_t node) const
{
auto pool = get(node);
if (!pool) {
pool = new MemoryPool(m_nodeSize, m_hugePages, node);
m_map.insert({ node, pool });
auto new_pool = std::make_shared<MemoryPool>(m_nodeSize, m_hugePages, node);
m_map.emplace(node, new_pool);
pool = new_pool.get();
}
return pool;

4
src/crypto/common/NUMAMemoryPool.h
View file

@ -47,7 +47,7 @@ public:
XMRIG_DISABLE_COPY_MOVE_DEFAULT(NUMAMemoryPool)
NUMAMemoryPool(size_t size, bool hugePages);
~NUMAMemoryPool() override;
~NUMAMemoryPool() override = default;
protected:
bool isHugePages(uint32_t node) const override;
@ -61,7 +61,7 @@ private:
bool m_hugePages = true;
size_t m_nodeSize = 0;
size_t m_size = 0;
mutable std::map<uint32_t, IMemoryPool *> m_map;
mutable std::map<uint32_t, std::shared_ptr<IMemoryPool>> m_map;
};

8
src/crypto/common/VirtualMemory.cpp
View file

@ -38,7 +38,7 @@ namespace xmrig {
size_t VirtualMemory::m_hugePageSize = VirtualMemory::kDefaultHugePageSize;
static IMemoryPool *pool = nullptr;
static std::shared_ptr<IMemoryPool> pool;
static std::mutex mutex;
@ -113,7 +113,7 @@ uint32_t xmrig::VirtualMemory::bindToNUMANode(int64_t)
void xmrig::VirtualMemory::destroy()
{
delete pool;
pool.reset();
}
@ -125,10 +125,10 @@ void xmrig::VirtualMemory::init(size_t poolSize, size_t hugePageSize)
# ifdef XMRIG_FEATURE_HWLOC
if (Cpu::info()->nodes() > 1) {
pool = new NUMAMemoryPool(align(poolSize, Cpu::info()->nodes()), hugePageSize > 0);
pool = std::make_shared<NUMAMemoryPool>(align(poolSize, Cpu::info()->nodes()), hugePageSize > 0);
} else
# endif
{
pool = new MemoryPool(poolSize, hugePageSize > 0);
pool = std::make_shared<MemoryPool>(poolSize, hugePageSize > 0);
}
}

3
src/crypto/ghostrider/ghostrider.cpp
View file

@ -312,7 +312,7 @@ void benchmark()
constexpr uint32_t N = 1U << 21;
VirtualMemory::init(0, N);
VirtualMemory* memory = new VirtualMemory(N * 8, true, false, false);
std::shared_ptr<VirtualMemory> memory = std::make_shared<VirtualMemory>(N * 8, true, false, false);
// 2 MB cache per core by default
size_t max_scratchpad_size = 1U << 21;
@ -438,7 +438,6 @@ void benchmark()
delete helper;
CnCtx::release(ctx, 8);
delete memory;
});
t.join();

14
src/crypto/kawpow/KPCache.cpp
View file

@ -38,17 +38,6 @@ std::mutex KPCache::s_cacheMutex;
KPCache KPCache::s_cache;
KPCache::KPCache()
{
}
KPCache::~KPCache()
{
delete m_memory;
}
bool KPCache::init(uint32_t epoch)
{
if (epoch >= sizeof(cache_sizes) / sizeof(cache_sizes[0])) {
@ -63,8 +52,7 @@ bool KPCache::init(uint32_t epoch)
const size_t size = cache_sizes[epoch];
if (!m_memory || m_memory->size() < size) {
delete m_memory;
m_memory = new VirtualMemory(size, false, false, false);
m_memory = std::make_shared<VirtualMemory>(size, false, false, false);
}
const ethash_h256_t seedhash = ethash_get_seedhash(epoch);

6
src/crypto/kawpow/KPCache.h
View file

@ -41,8 +41,8 @@ public:
XMRIG_DISABLE_COPY_MOVE(KPCache)
KPCache();
~KPCache();
KPCache() = default;
~KPCache() = default;
bool init(uint32_t epoch);
@ -61,7 +61,7 @@ public:
static KPCache s_cache;
private:
VirtualMemory* m_memory = nullptr;
std::shared_ptr<VirtualMemory> m_memory;
size_t m_size = 0;
uint32_t m_epoch = 0xFFFFFFFFUL;
std::vector<uint32_t> m_DAGCache;

8
src/crypto/rx/Rx.cpp
View file

@ -40,7 +40,7 @@ class RxPrivate;
static bool osInitialized = false;
static RxPrivate *d_ptr = nullptr;
static std::shared_ptr<RxPrivate> d_ptr;
class RxPrivate
@ -73,15 +73,13 @@ void xmrig::Rx::destroy()
RxMsr::destroy();
# endif
delete d_ptr;
d_ptr = nullptr;
d_ptr.reset();
}
void xmrig::Rx::init(IRxListener *listener)
{
d_ptr = new RxPrivate(listener);
d_ptr = std::make_shared<RxPrivate>(listener);
}

9
src/crypto/rx/RxBasicStorage.cpp
View file

@ -44,8 +44,8 @@ public:
inline ~RxBasicStoragePrivate() { deleteDataset(); }
inline bool isReady(const Job &job) const { return m_ready && m_seed == job; }
inline RxDataset *dataset() const { return m_dataset; }
inline void deleteDataset() { delete m_dataset; m_dataset = nullptr; }
inline RxDataset *dataset() const { return m_dataset.get(); }
inline void deleteDataset() { m_dataset.reset(); }
inline void setSeed(const RxSeed &seed)
@ -64,7 +64,7 @@ public:
{
const uint64_t ts = Chrono::steadyMSecs();
m_dataset = new RxDataset(hugePages, oneGbPages, true, mode, 0);
m_dataset = std::make_shared<RxDataset>(hugePages, oneGbPages, true, mode, 0);
if (!m_dataset->cache()->get()) {
deleteDataset();
@ -117,7 +117,7 @@ private:
bool m_ready = false;
RxDataset *m_dataset = nullptr;
std::shared_ptr<RxDataset> m_dataset;
RxSeed m_seed;
};
@ -133,7 +133,6 @@ xmrig::RxBasicStorage::RxBasicStorage() :
xmrig::RxBasicStorage::~RxBasicStorage()
{
delete d_ptr;
}

2
src/crypto/rx/RxBasicStorage.h
View file

@ -46,7 +46,7 @@ protected:
void init(const RxSeed &seed, uint32_t threads, bool hugePages, bool oneGbPages, RxConfig::Mode mode, int priority) override;
private:
RxBasicStoragePrivate *d_ptr;
std::shared_ptr<RxBasicStoragePrivate> d_ptr;
};

4
src/crypto/rx/RxCache.cpp
View file

@ -35,7 +35,7 @@ static_assert(RANDOMX_FLAG_JIT == 8, "RANDOMX_FLAG_JIT flag mismatch");
xmrig::RxCache::RxCache(bool hugePages, uint32_t nodeId)
{
m_memory = new VirtualMemory(maxSize(), hugePages, false, false, nodeId);
m_memory = std::make_shared<VirtualMemory>(maxSize(), hugePages, false, false, nodeId);
create(m_memory->raw());
}
@ -50,8 +50,6 @@ xmrig::RxCache::RxCache(uint8_t *memory)
xmrig::RxCache::~RxCache()
{
randomx_release_cache(m_cache);
delete m_memory;
}

2
src/crypto/rx/RxCache.h
View file

@ -69,7 +69,7 @@ private:
bool m_jit = true;
Buffer m_seed;
randomx_cache *m_cache = nullptr;
VirtualMemory *m_memory = nullptr;
std::shared_ptr<VirtualMemory> m_memory;
};

17
src/crypto/rx/RxDataset.cpp
View file

@ -79,10 +79,7 @@ xmrig::RxDataset::RxDataset(RxCache *cache) :
xmrig::RxDataset::~RxDataset()
{
randomx_release_dataset(m_dataset);
delete m_cache;
delete m_memory;
}
@ -107,7 +104,7 @@ bool xmrig::RxDataset::init(const Buffer &seed, uint32_t numThreads, int priorit
for (uint64_t i = 0; i < numThreads; ++i) {
const uint32_t a = (datasetItemCount * i) / numThreads;
const uint32_t b = (datasetItemCount * (i + 1)) / numThreads;
threads.emplace_back(init_dataset_wrapper, m_dataset, m_cache->get(), a, b - a, priority);
threads.emplace_back(init_dataset_wrapper, m_dataset.get(), m_cache->get(), a, b - a, priority);
}
for (uint32_t i = 0; i < numThreads; ++i) {
@ -115,7 +112,7 @@ bool xmrig::RxDataset::init(const Buffer &seed, uint32_t numThreads, int priorit
}
}
else {
init_dataset_wrapper(m_dataset, m_cache->get(), 0, datasetItemCount, priority);
init_dataset_wrapper(m_dataset.get(), m_cache->get(), 0, datasetItemCount, priority);
}
return true;
@ -180,7 +177,7 @@ uint8_t *xmrig::RxDataset::tryAllocateScrathpad()
void *xmrig::RxDataset::raw() const
{
return m_dataset ? randomx_get_dataset_memory(m_dataset) : nullptr;
return m_dataset ? randomx_get_dataset_memory(m_dataset.get()) : nullptr;
}
@ -191,7 +188,7 @@ void xmrig::RxDataset::setRaw(const void *raw)
}
volatile size_t N = maxSize();
memcpy(randomx_get_dataset_memory(m_dataset), raw, N);
memcpy(randomx_get_dataset_memory(m_dataset.get()), raw, N);
}
@ -199,24 +196,22 @@ void xmrig::RxDataset::allocate(bool hugePages, bool oneGbPages)
{
if (m_mode == RxConfig::LightMode) {
LOG_ERR(CLEAR "%s" RED_BOLD_S "fast RandomX mode disabled by config", Tags::randomx());
return;
}
if (m_mode == RxConfig::AutoMode && uv_get_total_memory() < (maxSize() + RxCache::maxSize())) {
LOG_ERR(CLEAR "%s" RED_BOLD_S "not enough memory for RandomX dataset", Tags::randomx());
return;
}
m_memory = new VirtualMemory(maxSize(), hugePages, oneGbPages, false, m_node);
m_memory = std::make_shared<VirtualMemory>(maxSize(), hugePages, oneGbPages, false, m_node);
if (m_memory->isOneGbPages()) {
m_scratchpadOffset = maxSize() + RANDOMX_CACHE_MAX_SIZE;
m_scratchpadLimit = m_memory->capacity();
}
m_dataset = randomx_create_dataset(m_memory->raw());
m_dataset = std::shared_ptr<randomx_dataset>(randomx_create_dataset(m_memory->raw()), randomx_release_dataset);
# ifdef XMRIG_OS_LINUX
if (oneGbPages && !isOneGbPages()) {

6
src/crypto/rx/RxDataset.h
View file

@ -50,7 +50,7 @@ public:
RxDataset(RxCache *cache);
~RxDataset();
inline randomx_dataset *get() const { return m_dataset; }
inline randomx_dataset *get() const { return m_dataset.get(); }
inline RxCache *cache() const { return m_cache; }
inline void setCache(RxCache *cache) { m_cache = cache; }
@ -70,11 +70,11 @@ private:
const RxConfig::Mode m_mode = RxConfig::FastMode;
const uint32_t m_node;
randomx_dataset *m_dataset = nullptr;
std::shared_ptr<randomx_dataset> m_dataset;
RxCache *m_cache = nullptr;
size_t m_scratchpadLimit = 0;
std::atomic<size_t> m_scratchpadOffset{};
VirtualMemory *m_memory = nullptr;
std::shared_ptr<VirtualMemory> m_memory;
};

6
src/crypto/rx/RxQueue.cpp
View file

@ -49,8 +49,6 @@ xmrig::RxQueue::~RxQueue()
m_cv.notify_one();
m_thread.join();
delete m_storage;
}
@ -90,12 +88,12 @@ void xmrig::RxQueue::enqueue(const RxSeed &seed, const std::vector<uint32_t> &no
if (!m_storage) {
# ifdef XMRIG_FEATURE_HWLOC
if (!nodeset.empty()) {
m_storage = new RxNUMAStorage(nodeset);
m_storage = std::make_shared<RxNUMAStorage>(nodeset);
}
else
# endif
{
m_storage = new RxBasicStorage();
m_storage = std::make_shared<RxBasicStorage>();
}
}

2
src/crypto/rx/RxQueue.h
View file

@ -94,7 +94,7 @@ private:
void onReady();
IRxListener *m_listener = nullptr;
IRxStorage *m_storage = nullptr;
std::shared_ptr<IRxStorage> m_storage;
RxSeed m_seed;
State m_state = STATE_IDLE;
std::condition_variable m_cv;

13
src/crypto/rx/RxVm.cpp
View file

@ -25,7 +25,7 @@
#include "crypto/rx/RxVm.h"
randomx_vm *xmrig::RxVm::create(RxDataset *dataset, uint8_t *scratchpad, bool softAes, const Assembly &assembly, uint32_t node)
std::shared_ptr<randomx_vm> xmrig::RxVm::create(RxDataset *dataset, uint8_t *scratchpad, bool softAes, const Assembly &assembly, uint32_t node)
{
int flags = 0;
@ -46,13 +46,8 @@ randomx_vm *xmrig::RxVm::create(RxDataset *dataset, uint8_t *scratchpad, bool so
flags |= RANDOMX_FLAG_AMD;
}
return randomx_create_vm(static_cast<randomx_flags>(flags), !dataset->get() ? dataset->cache()->get() : nullptr, dataset->get(), scratchpad, node);
return std::shared_ptr<randomx_vm>(randomx_create_vm(
static_cast<randomx_flags>(flags), !dataset->get() ? dataset->cache()->get() : nullptr, dataset->get(), scratchpad, node),
randomx_destroy_vm);
}
void xmrig::RxVm::destroy(randomx_vm* vm)
{
if (vm) {
randomx_destroy_vm(vm);
}
}

3
src/crypto/rx/RxVm.h
View file

@ -38,8 +38,7 @@ class RxDataset;
class RxVm
{
public:
static randomx_vm *create(RxDataset *dataset, uint8_t *scratchpad, bool softAes, const Assembly &assembly, uint32_t node);
static void destroy(randomx_vm *vm);
static std::shared_ptr<randomx_vm> create(RxDataset *dataset, uint8_t *scratchpad, bool softAes, const Assembly &assembly, uint32_t node);
};

2
src/hw/msr/Msr.h
View file

@ -59,7 +59,7 @@ private:
bool rdmsr(uint32_t reg, int32_t cpu, uint64_t &value) const;
bool wrmsr(uint32_t reg, uint64_t value, int32_t cpu);
MsrPrivate *d_ptr = nullptr;
std::shared_ptr<MsrPrivate> d_ptr;
};

5
src/hw/msr/Msr_linux.cpp
View file

@ -72,11 +72,9 @@ private:
const bool m_available;
};
} // namespace xmrig
xmrig::Msr::Msr() : d_ptr(new MsrPrivate())
xmrig::Msr::Msr() : d_ptr(std::make_shared<MsrPrivate>())
{
if (!isAvailable()) {
LOG_WARN("%s " YELLOW_BOLD("msr kernel module is not available"), tag());
@ -86,7 +84,6 @@ xmrig::Msr::Msr() : d_ptr(new MsrPrivate())
xmrig::Msr::~Msr()
{
delete d_ptr;
}

4
src/hw/msr/Msr_win.cpp
View file

@ -85,7 +85,7 @@ public:
} // namespace xmrig
xmrig::Msr::Msr() : d_ptr(new MsrPrivate())
xmrig::Msr::Msr() : d_ptr(std::make_shared<MsrPrivate>())
{
DWORD err = 0;
@ -195,8 +195,6 @@ xmrig::Msr::Msr() : d_ptr(new MsrPrivate())
xmrig::Msr::~Msr()
{
d_ptr->uninstall();
delete d_ptr;
}

18
src/net/JobResults.cpp
View file

@ -133,12 +133,10 @@ static void getResults(JobBundle &bundle, std::vector<JobResult> &results, uint3
for (uint32_t nonce : bundle.nonces) {
*bundle.job.nonce() = nonce;
randomx_calculate_hash(vm, bundle.job.blob(), bundle.job.size(), hash);
randomx_calculate_hash(vm.get(), bundle.job.blob(), bundle.job.size(), hash);
checkHash(bundle, results, nonce, hash, errors);
}
RxVm::destroy(vm);
# endif
}
else if (algorithm.family() == Algorithm::ARGON2) {
@ -303,7 +301,7 @@ private:
};
static JobResultsPrivate *handler = nullptr;
static std::shared_ptr<JobResultsPrivate> handler;
} // namespace xmrig
@ -317,19 +315,17 @@ void xmrig::JobResults::done(const Job &job)
void xmrig::JobResults::setListener(IJobResultListener *listener, bool hwAES)
{
assert(handler == nullptr);
assert(!handler);
handler = new JobResultsPrivate(listener, hwAES);
handler = std::make_shared<JobResultsPrivate>(listener, hwAES);
}
void xmrig::JobResults::stop()
{
assert(handler != nullptr);
assert(handler);
delete handler;
handler = nullptr;
handler.reset();
}
@ -347,7 +343,7 @@ void xmrig::JobResults::submit(const Job& job, uint32_t nonce, const uint8_t* re
void xmrig::JobResults::submit(const JobResult &result)
{
assert(handler != nullptr);
assert(handler);
if (handler) {
handler->submit(result);

27
src/net/Network.cpp
View file

@ -67,27 +67,23 @@ xmrig::Network::Network(Controller *controller) :
controller->api()->addListener(this);
# endif
m_state = new NetworkState(this);
m_state = std::make_shared<NetworkState>(this);
const Pools &pools = controller->config()->pools();
m_strategy = pools.createStrategy(m_state);
m_strategy = pools.createStrategy(m_state.get());
if (pools.donateLevel() > 0) {
m_donate = new DonateStrategy(controller, this);
m_donate = std::make_shared<DonateStrategy>(controller, this);
}
m_timer = new Timer(this, kTickInterval, kTickInterval);
static constexpr int kTickInterval = 1 * 1000;
m_timer = std::make_shared<Timer>(this, kTickInterval, kTickInterval);
}
xmrig::Network::~Network()
{
JobResults::stop();
delete m_timer;
delete m_donate;
delete m_strategy;
delete m_state;
}
@ -118,7 +114,7 @@ void xmrig::Network::execCommand(char command)
void xmrig::Network::onActive(IStrategy *strategy, IClient *client)
{
if (m_donate && m_donate == strategy) {
if (m_donate && m_donate.get() == strategy) {
LOG_NOTICE("%s " WHITE_BOLD("dev donate started"), Tags::network());
return;
}
@ -157,19 +153,18 @@ void xmrig::Network::onConfigChanged(Config *config, Config *previousConfig)
config->pools().print();
delete m_strategy;
m_strategy = config->pools().createStrategy(m_state);
m_strategy = config->pools().createStrategy(m_state.get());
connect();
}
void xmrig::Network::onJob(IStrategy *strategy, IClient *client, const Job &job, const rapidjson::Value &)
{
if (m_donate && m_donate->isActive() && m_donate != strategy) {
if (m_donate && m_donate->isActive() && m_donate.get() != strategy) {
return;
}
setJob(client, job, m_donate == strategy);
setJob(client, job, m_donate.get() == strategy);
}
@ -210,7 +205,7 @@ void xmrig::Network::onLogin(IStrategy *, IClient *client, rapidjson::Document &
void xmrig::Network::onPause(IStrategy *strategy)
{
if (m_donate && m_donate == strategy) {
if (m_donate && m_donate.get() == strategy) {
LOG_NOTICE("%s " WHITE_BOLD("dev donate finished"), Tags::network());
m_strategy->resume();
}
@ -292,7 +287,7 @@ void xmrig::Network::setJob(IClient *client, const Job &job, bool donate)
}
if (!donate && m_donate) {
static_cast<DonateStrategy *>(m_donate)->update(client, job);
static_cast<DonateStrategy &>(*m_donate).update(client, job);
}
m_controller->miner()->setJob(job, donate);

14
src/net/Network.h
View file

@ -30,7 +30,7 @@
#include "interfaces/IJobResultListener.h"
#include <vector>
#include <memory>
namespace xmrig {
@ -49,7 +49,7 @@ public:
Network(Controller *controller);
~Network() override;
inline IStrategy *strategy() const { return m_strategy; }
inline IStrategy *strategy() const { return m_strategy.get(); }
void connect();
void execCommand(char command);
@ -71,8 +71,6 @@ protected:
# endif
private:
constexpr static int kTickInterval = 1 * 1000;
void setJob(IClient *client, const Job &job, bool donate);
void tick();
@ -82,10 +80,10 @@ private:
# endif
Controller *m_controller;
IStrategy *m_donate = nullptr;
IStrategy *m_strategy = nullptr;
NetworkState *m_state = nullptr;
Timer *m_timer = nullptr;
std::shared_ptr<IStrategy> m_donate;
std::shared_ptr<IStrategy> m_strategy;
std::shared_ptr<NetworkState> m_state;
std::shared_ptr<Timer> m_timer;
};

14
src/net/strategies/DonateStrategy.cpp
View file

@ -75,13 +75,13 @@ xmrig::DonateStrategy::DonateStrategy(Controller *controller, IStrategyListener
m_pools.emplace_back(kDonateHost, 3333, m_userId, nullptr, nullptr, 0, true, false, mode);
if (m_pools.size() > 1) {
m_strategy = new FailoverStrategy(m_pools, 10, 2, this, true);
m_strategy = std::make_shared<FailoverStrategy>(m_pools, 10, 2, this, true);
}
else {
m_strategy = new SinglePoolStrategy(m_pools.front(), 10, 2, this, true);
m_strategy = std::make_shared<SinglePoolStrategy>(m_pools.front(), 10, 2, this, true);
}
m_timer = new Timer(this);
m_timer = std::make_shared<Timer>(this);
setState(STATE_IDLE);
}
@ -89,8 +89,8 @@ xmrig::DonateStrategy::DonateStrategy(Controller *controller, IStrategyListener
xmrig::DonateStrategy::~DonateStrategy()
{
delete m_timer;
delete m_strategy;
m_timer.reset();
m_strategy.reset();
if (m_proxy) {
m_proxy->deleteLater();
@ -249,7 +249,7 @@ void xmrig::DonateStrategy::onTimer(const Timer *)
}
xmrig::IClient *xmrig::DonateStrategy::createProxy()
std::shared_ptr<xmrig::IClient> xmrig::DonateStrategy::createProxy()
{
if (m_controller->config()->pools().proxyDonate() == Pools::PROXY_DONATE_NONE) {
return nullptr;
@ -267,7 +267,7 @@ xmrig::IClient *xmrig::DonateStrategy::createProxy()
pool.setAlgo(client->pool().algorithm());
pool.setProxy(client->pool().proxy());
IClient *proxy = new Client(-1, Platform::userAgent(), this);
std::shared_ptr<IClient> proxy = std::make_shared<Client>(-1, Platform::userAgent(), this);
proxy->setPool(pool);
proxy->setQuiet(true);

10
src/net/strategies/DonateStrategy.h
View file

@ -47,7 +47,7 @@ public:
protected:
inline bool isActive() const override { return state() == STATE_ACTIVE; }
inline IClient *client() const override { return m_proxy ? m_proxy : m_strategy->client(); }
inline IClient *client() const override { return m_proxy ? m_proxy.get() : m_strategy->client(); }
inline void onJob(IStrategy *, IClient *client, const Job &job, const rapidjson::Value &params) override { setJob(client, job, params); }
inline void onJobReceived(IClient *client, const Job &job, const rapidjson::Value &params) override { setJob(client, job, params); }
inline void onResultAccepted(IClient *client, const SubmitResult &result, const char *error) override { setResult(client, result, error); }
@ -84,7 +84,7 @@ private:
inline State state() const { return m_state; }
IClient *createProxy();
std::shared_ptr<IClient> createProxy();
void idle(double min, double max);
void setJob(IClient *client, const Job &job, const rapidjson::Value &params);
void setParams(rapidjson::Document &doc, rapidjson::Value &params);
@ -98,12 +98,12 @@ private:
const uint64_t m_donateTime;
const uint64_t m_idleTime;
Controller *m_controller;
IClient *m_proxy = nullptr;
IStrategy *m_strategy = nullptr;
std::shared_ptr<IClient> m_proxy;
std::shared_ptr<IStrategy> m_strategy;
IStrategyListener *m_listener;
State m_state = STATE_NEW;
std::vector<Pool> m_pools;
Timer *m_timer = nullptr;
std::shared_ptr<Timer> m_timer;
uint64_t m_diff = 0;
uint64_t m_height = 0;
uint64_t m_now = 0;