mirrors/xmrig
1
0
Fork 1
mirror of https://github.com/xmrig/xmrig.git synced 2026-02-03 02:23:05 -05:00
Code Issues Projects Releases Wiki Activity

Merge ab5be0b773 into e8bbd134f9

Browse Source
This commit is contained in:
Artem Zuikov
2024-11-03 19:13:18 +02:00
committed by GitHub
parent e8bbd134f9 ab5be0b773
commit 0f63d23d9f
71 changed files with 271 additions and 387 deletions
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;
};