Merged v4.3.0-beta
This commit is contained in:
MoneroOcean
commit
fe76800fc8
101 changed files with 10318 additions and 7615 deletions
|
|
@ -111,6 +111,8 @@ static AlgoName const algorithm_names[] = {
|
|||
{ "randomx/loki", "rx/loki", Algorithm::RX_LOKI },
|
||||
{ "RandomXL", nullptr, Algorithm::RX_LOKI },
|
||||
{ "DefyX", "defyx", Algorithm::DEFYX },
|
||||
{ "randomx/arq", "rx/arq", Algorithm::RX_ARQ },
|
||||
{ "RandomARQ", nullptr, Algorithm::RX_ARQ },
|
||||
# endif
|
||||
# ifdef XMRIG_ALGO_ARGON2
|
||||
{ "argon2/chukwa", nullptr, Algorithm::AR2_CHUKWA },
|
||||
|
|
@ -145,6 +147,9 @@ size_t xmrig::Algorithm::l2() const
|
|||
case DEFYX:
|
||||
return 0x20000;
|
||||
|
||||
case RX_ARQ:
|
||||
return 0x10000;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
|
@ -178,6 +183,9 @@ size_t xmrig::Algorithm::l3() const
|
|||
case DEFYX:
|
||||
return 0x40000;
|
||||
|
||||
case RX_ARQ:
|
||||
return oneMiB / 4;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
|
@ -269,6 +277,7 @@ xmrig::Algorithm::Family xmrig::Algorithm::family(Id id)
|
|||
case RX_WOW:
|
||||
case RX_LOKI:
|
||||
case DEFYX:
|
||||
case RX_ARQ:
|
||||
return RANDOM_X;
|
||||
# endif
|
||||
|
||||
|
|
|
|||
|
|
@ -67,6 +67,7 @@ public:
|
|||
RX_WOW, // "rx/wow" RandomWOW (Wownero).
|
||||
RX_LOKI, // "rx/loki" RandomXL (Loki).
|
||||
DEFYX, // "defyx" DefyX (Scala).
|
||||
RX_ARQ, // "rx/arq" RandomARQ (Arqma).
|
||||
AR2_CHUKWA, // "argon2/chukwa" Argon2id (Chukwa).
|
||||
AR2_WRKZ, // "argon2/wrkz" Argon2id (WRKZ)
|
||||
MAX
|
||||
|
|
|
|||
|
|
@ -49,6 +49,8 @@ struct CoinName
|
|||
static CoinName const coin_names[] = {
|
||||
{ "monero", Coin::MONERO },
|
||||
{ "xmr", Coin::MONERO },
|
||||
{ "arqma", Coin::ARQMA },
|
||||
{ "arq", Coin::ARQMA }
|
||||
};
|
||||
|
||||
|
||||
|
|
@ -58,8 +60,15 @@ static CoinName const coin_names[] = {
|
|||
|
||||
xmrig::Algorithm::Id xmrig::Coin::algorithm(uint8_t blobVersion) const
|
||||
{
|
||||
if (id() == MONERO) {
|
||||
switch (id()) {
|
||||
case MONERO:
|
||||
return (blobVersion >= 12) ? Algorithm::RX_0 : Algorithm::CN_R;
|
||||
|
||||
case ARQMA:
|
||||
return (blobVersion >= 15) ? Algorithm::RX_ARQ : Algorithm::CN_PICO_0;
|
||||
|
||||
case INVALID:
|
||||
break;
|
||||
}
|
||||
|
||||
return Algorithm::INVALID;
|
||||
|
|
|
|||
|
|
@ -40,6 +40,7 @@ public:
|
|||
enum Id : int {
|
||||
INVALID = -1,
|
||||
MONERO,
|
||||
ARQMA
|
||||
};
|
||||
|
||||
|
||||
|
|
|
|||
95
src/crypto/common/MemoryPool.cpp
Normal file
95
src/crypto/common/MemoryPool.cpp
Normal file
|
|
@ -0,0 +1,95 @@
|
|||
/* XMRig
|
||||
* Copyright 2010 Jeff Garzik <jgarzik@pobox.com>
|
||||
* Copyright 2012-2014 pooler <pooler@litecoinpool.org>
|
||||
* Copyright 2014 Lucas Jones <https://github.com/lucasjones>
|
||||
* Copyright 2014-2016 Wolf9466 <https://github.com/OhGodAPet>
|
||||
* Copyright 2016 Jay D Dee <jayddee246@gmail.com>
|
||||
* Copyright 2017-2018 XMR-Stak <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
|
||||
* Copyright 2018 Lee Clagett <https://github.com/vtnerd>
|
||||
* Copyright 2018-2019 SChernykh <https://github.com/SChernykh>
|
||||
* Copyright 2018-2019 tevador <tevador@gmail.com>
|
||||
* Copyright 2016-2019 XMRig <https://github.com/xmrig>, <support@xmrig.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
|
||||
#include "crypto/common/MemoryPool.h"
|
||||
#include "crypto/common/VirtualMemory.h"
|
||||
|
||||
|
||||
#include <cassert>
|
||||
|
||||
|
||||
namespace xmrig {
|
||||
|
||||
|
||||
constexpr size_t pageSize = 2 * 1024 * 1024;
|
||||
|
||||
|
||||
} // namespace xmrig
|
||||
|
||||
|
||||
xmrig::MemoryPool::MemoryPool(size_t size, bool hugePages, uint32_t node) :
|
||||
m_size(size)
|
||||
{
|
||||
if (!size) {
|
||||
return;
|
||||
}
|
||||
|
||||
m_memory = new VirtualMemory(size * pageSize, hugePages, false, node);
|
||||
}
|
||||
|
||||
|
||||
xmrig::MemoryPool::~MemoryPool()
|
||||
{
|
||||
delete m_memory;
|
||||
}
|
||||
|
||||
|
||||
bool xmrig::MemoryPool::isHugePages(uint32_t) const
|
||||
{
|
||||
return m_memory && m_memory->isHugePages();
|
||||
}
|
||||
|
||||
|
||||
uint8_t *xmrig::MemoryPool::get(size_t size, uint32_t)
|
||||
{
|
||||
assert(!(size % pageSize));
|
||||
|
||||
if (!m_memory || (m_memory->size() - m_offset) < size) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
uint8_t *out = m_memory->scratchpad() + m_offset;
|
||||
|
||||
m_offset += size;
|
||||
++m_refs;
|
||||
|
||||
return out;
|
||||
}
|
||||
|
||||
|
||||
void xmrig::MemoryPool::release(uint32_t)
|
||||
{
|
||||
assert(m_refs > 0);
|
||||
|
||||
if (m_refs > 0) {
|
||||
--m_refs;
|
||||
}
|
||||
|
||||
if (m_refs == 0) {
|
||||
m_offset = 0;
|
||||
}
|
||||
}
|
||||
66
src/crypto/common/MemoryPool.h
Normal file
66
src/crypto/common/MemoryPool.h
Normal file
|
|
@ -0,0 +1,66 @@
|
|||
/* XMRig
|
||||
* Copyright 2010 Jeff Garzik <jgarzik@pobox.com>
|
||||
* Copyright 2012-2014 pooler <pooler@litecoinpool.org>
|
||||
* Copyright 2014 Lucas Jones <https://github.com/lucasjones>
|
||||
* Copyright 2014-2016 Wolf9466 <https://github.com/OhGodAPet>
|
||||
* Copyright 2016 Jay D Dee <jayddee246@gmail.com>
|
||||
* Copyright 2017-2018 XMR-Stak <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
|
||||
* Copyright 2018 Lee Clagett <https://github.com/vtnerd>
|
||||
* Copyright 2018-2019 SChernykh <https://github.com/SChernykh>
|
||||
* Copyright 2018-2019 tevador <tevador@gmail.com>
|
||||
* Copyright 2016-2019 XMRig <https://github.com/xmrig>, <support@xmrig.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef XMRIG_MEMORYPOOL_H
|
||||
#define XMRIG_MEMORYPOOL_H
|
||||
|
||||
|
||||
#include "backend/common/interfaces/IMemoryPool.h"
|
||||
#include "base/tools/Object.h"
|
||||
|
||||
|
||||
namespace xmrig {
|
||||
|
||||
|
||||
class VirtualMemory;
|
||||
|
||||
|
||||
class MemoryPool : public IMemoryPool
|
||||
{
|
||||
public:
|
||||
XMRIG_DISABLE_COPY_MOVE_DEFAULT(MemoryPool)
|
||||
|
||||
MemoryPool(size_t size, bool hugePages, uint32_t node = 0);
|
||||
~MemoryPool() override;
|
||||
|
||||
protected:
|
||||
bool isHugePages(uint32_t node) const override;
|
||||
uint8_t *get(size_t size, uint32_t node) override;
|
||||
void release(uint32_t node) override;
|
||||
|
||||
private:
|
||||
size_t m_size = 0;
|
||||
size_t m_refs = 0;
|
||||
size_t m_offset = 0;
|
||||
VirtualMemory *m_memory = nullptr;
|
||||
};
|
||||
|
||||
|
||||
} /* namespace xmrig */
|
||||
|
||||
|
||||
|
||||
#endif /* XMRIG_MEMORYPOOL_H */
|
||||
106
src/crypto/common/NUMAMemoryPool.cpp
Normal file
106
src/crypto/common/NUMAMemoryPool.cpp
Normal file
|
|
@ -0,0 +1,106 @@
|
|||
/* XMRig
|
||||
* Copyright 2010 Jeff Garzik <jgarzik@pobox.com>
|
||||
* Copyright 2012-2014 pooler <pooler@litecoinpool.org>
|
||||
* Copyright 2014 Lucas Jones <https://github.com/lucasjones>
|
||||
* Copyright 2014-2016 Wolf9466 <https://github.com/OhGodAPet>
|
||||
* Copyright 2016 Jay D Dee <jayddee246@gmail.com>
|
||||
* Copyright 2017-2018 XMR-Stak <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
|
||||
* Copyright 2018 Lee Clagett <https://github.com/vtnerd>
|
||||
* Copyright 2018-2019 SChernykh <https://github.com/SChernykh>
|
||||
* Copyright 2018-2019 tevador <tevador@gmail.com>
|
||||
* Copyright 2016-2019 XMRig <https://github.com/xmrig>, <support@xmrig.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
|
||||
#include "crypto/common/NUMAMemoryPool.h"
|
||||
#include "crypto/common/VirtualMemory.h"
|
||||
#include "backend/cpu/Cpu.h"
|
||||
#include "crypto/common/MemoryPool.h"
|
||||
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
|
||||
namespace xmrig {
|
||||
|
||||
|
||||
constexpr size_t pageSize = 2 * 1024 * 1024;
|
||||
|
||||
|
||||
} // namespace xmrig
|
||||
|
||||
|
||||
xmrig::NUMAMemoryPool::NUMAMemoryPool(size_t size, bool hugePages) :
|
||||
m_hugePages(hugePages),
|
||||
m_nodeSize(std::max<size_t>(size / Cpu::info()->nodes(), 1)),
|
||||
m_size(size)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
xmrig::NUMAMemoryPool::~NUMAMemoryPool()
|
||||
{
|
||||
for (auto kv : m_map) {
|
||||
delete kv.second;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
bool xmrig::NUMAMemoryPool::isHugePages(uint32_t node) const
|
||||
{
|
||||
if (!m_size) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return getOrCreate(node)->isHugePages(node);
|
||||
}
|
||||
|
||||
|
||||
uint8_t *xmrig::NUMAMemoryPool::get(size_t size, uint32_t node)
|
||||
{
|
||||
if (!m_size) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
return getOrCreate(node)->get(size, node);
|
||||
}
|
||||
|
||||
|
||||
void xmrig::NUMAMemoryPool::release(uint32_t node)
|
||||
{
|
||||
const auto pool = get(node);
|
||||
if (pool) {
|
||||
pool->release(node);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
xmrig::IMemoryPool *xmrig::NUMAMemoryPool::get(uint32_t node) const
|
||||
{
|
||||
return m_map.count(node) ? m_map.at(node) : nullptr;
|
||||
}
|
||||
|
||||
|
||||
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 });
|
||||
}
|
||||
|
||||
return pool;
|
||||
}
|
||||
72
src/crypto/common/NUMAMemoryPool.h
Normal file
72
src/crypto/common/NUMAMemoryPool.h
Normal file
|
|
@ -0,0 +1,72 @@
|
|||
/* XMRig
|
||||
* Copyright 2010 Jeff Garzik <jgarzik@pobox.com>
|
||||
* Copyright 2012-2014 pooler <pooler@litecoinpool.org>
|
||||
* Copyright 2014 Lucas Jones <https://github.com/lucasjones>
|
||||
* Copyright 2014-2016 Wolf9466 <https://github.com/OhGodAPet>
|
||||
* Copyright 2016 Jay D Dee <jayddee246@gmail.com>
|
||||
* Copyright 2017-2018 XMR-Stak <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
|
||||
* Copyright 2018 Lee Clagett <https://github.com/vtnerd>
|
||||
* Copyright 2018-2019 SChernykh <https://github.com/SChernykh>
|
||||
* Copyright 2018-2019 tevador <tevador@gmail.com>
|
||||
* Copyright 2016-2019 XMRig <https://github.com/xmrig>, <support@xmrig.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef XMRIG_NUMAMEMORYPOOL_H
|
||||
#define XMRIG_NUMAMEMORYPOOL_H
|
||||
|
||||
|
||||
#include "backend/common/interfaces/IMemoryPool.h"
|
||||
#include "base/tools/Object.h"
|
||||
|
||||
|
||||
#include <map>
|
||||
|
||||
|
||||
namespace xmrig {
|
||||
|
||||
|
||||
class IMemoryPool;
|
||||
|
||||
|
||||
class NUMAMemoryPool : public IMemoryPool
|
||||
{
|
||||
public:
|
||||
XMRIG_DISABLE_COPY_MOVE_DEFAULT(NUMAMemoryPool)
|
||||
|
||||
NUMAMemoryPool(size_t size, bool hugePages);
|
||||
~NUMAMemoryPool() override;
|
||||
|
||||
protected:
|
||||
bool isHugePages(uint32_t node) const override;
|
||||
uint8_t *get(size_t size, uint32_t node) override;
|
||||
void release(uint32_t node) override;
|
||||
|
||||
private:
|
||||
IMemoryPool *get(uint32_t node) const;
|
||||
IMemoryPool *getOrCreate(uint32_t node) const;
|
||||
|
||||
bool m_hugePages = true;
|
||||
size_t m_nodeSize = 0;
|
||||
size_t m_size = 0;
|
||||
mutable std::map<uint32_t, IMemoryPool *> m_map;
|
||||
};
|
||||
|
||||
|
||||
} /* namespace xmrig */
|
||||
|
||||
|
||||
|
||||
#endif /* XMRIG_NUMAMEMORYPOOL_H */
|
||||
|
|
@ -25,61 +25,102 @@
|
|||
*/
|
||||
|
||||
|
||||
#include "crypto/common/VirtualMemory.h"
|
||||
#include "backend/cpu/Cpu.h"
|
||||
#include "base/io/log/Log.h"
|
||||
#include "crypto/common/MemoryPool.h"
|
||||
#include "crypto/common/portable/mm_malloc.h"
|
||||
|
||||
|
||||
#ifdef XMRIG_FEATURE_HWLOC
|
||||
# include <hwloc.h>
|
||||
# include "backend/cpu/platform/HwlocCpuInfo.h"
|
||||
#
|
||||
# if HWLOC_API_VERSION < 0x00010b00
|
||||
# define HWLOC_OBJ_NUMANODE HWLOC_OBJ_NODE
|
||||
# endif
|
||||
# include "crypto/common/NUMAMemoryPool.h"
|
||||
#endif
|
||||
|
||||
|
||||
#include "base/io/log/Log.h"
|
||||
#include "crypto/common/VirtualMemory.h"
|
||||
#include <cinttypes>
|
||||
#include <mutex>
|
||||
|
||||
|
||||
uint32_t xmrig::VirtualMemory::bindToNUMANode(int64_t affinity)
|
||||
namespace xmrig {
|
||||
|
||||
static IMemoryPool *pool = nullptr;
|
||||
static std::mutex mutex;
|
||||
|
||||
} // namespace xmrig
|
||||
|
||||
|
||||
xmrig::VirtualMemory::VirtualMemory(size_t size, bool hugePages, bool usePool, uint32_t node, size_t alignSize) :
|
||||
m_size(align(size)),
|
||||
m_node(node)
|
||||
{
|
||||
# ifdef XMRIG_FEATURE_HWLOC
|
||||
if (affinity < 0 || !HwlocCpuInfo::has(HwlocCpuInfo::SET_THISTHREAD_MEMBIND)) {
|
||||
return 0;
|
||||
}
|
||||
if (usePool) {
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
if (hugePages && !pool->isHugePages(node) && allocateLargePagesMemory()) {
|
||||
return;
|
||||
}
|
||||
|
||||
hwloc_topology_t topology;
|
||||
hwloc_topology_init(&topology);
|
||||
hwloc_topology_load(topology);
|
||||
m_scratchpad = pool->get(m_size, node);
|
||||
if (m_scratchpad) {
|
||||
m_flags.set(FLAG_HUGEPAGES, pool->isHugePages(node));
|
||||
m_flags.set(FLAG_EXTERNAL, true);
|
||||
|
||||
const unsigned puId = static_cast<unsigned>(affinity);
|
||||
|
||||
hwloc_obj_t pu = hwloc_get_pu_obj_by_os_index(topology, puId);
|
||||
|
||||
# if HWLOC_API_VERSION >= 0x20000
|
||||
if (pu == nullptr || hwloc_set_membind(topology, pu->nodeset, HWLOC_MEMBIND_BIND, HWLOC_MEMBIND_THREAD | HWLOC_MEMBIND_BYNODESET) < 0) {
|
||||
# else
|
||||
if (pu == nullptr || hwloc_set_membind_nodeset(topology, pu->nodeset, HWLOC_MEMBIND_BIND, HWLOC_MEMBIND_THREAD) < 0) {
|
||||
# endif
|
||||
LOG_WARN("CPU #%02u warning: \"can't bind memory\"", puId);
|
||||
}
|
||||
|
||||
uint32_t nodeId = 0;
|
||||
|
||||
if (pu) {
|
||||
hwloc_obj_t node = nullptr;
|
||||
|
||||
while ((node = hwloc_get_next_obj_by_type(topology, HWLOC_OBJ_NUMANODE, node)) != nullptr) {
|
||||
if (hwloc_bitmap_intersects(node->cpuset, pu->cpuset)) {
|
||||
nodeId = node->os_index;
|
||||
|
||||
break;
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
hwloc_topology_destroy(topology);
|
||||
if (hugePages && allocateLargePagesMemory()) {
|
||||
return;
|
||||
}
|
||||
|
||||
return nodeId;
|
||||
# else
|
||||
return 0;
|
||||
# endif
|
||||
m_scratchpad = static_cast<uint8_t*>(_mm_malloc(m_size, alignSize));
|
||||
}
|
||||
|
||||
|
||||
xmrig::VirtualMemory::~VirtualMemory()
|
||||
{
|
||||
if (!m_scratchpad) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (m_flags.test(FLAG_EXTERNAL)) {
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
pool->release(m_node);
|
||||
}
|
||||
else if (isHugePages()) {
|
||||
freeLargePagesMemory();
|
||||
}
|
||||
else {
|
||||
_mm_free(m_scratchpad);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#ifndef XMRIG_FEATURE_HWLOC
|
||||
uint32_t xmrig::VirtualMemory::bindToNUMANode(int64_t)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
void xmrig::VirtualMemory::destroy()
|
||||
{
|
||||
delete pool;
|
||||
}
|
||||
|
||||
|
||||
void xmrig::VirtualMemory::init(size_t poolSize, bool hugePages)
|
||||
{
|
||||
if (!pool) {
|
||||
osInit();
|
||||
}
|
||||
|
||||
# ifdef XMRIG_FEATURE_HWLOC
|
||||
if (Cpu::info()->nodes() > 1) {
|
||||
pool = new NUMAMemoryPool(align(poolSize, Cpu::info()->nodes()), hugePages);
|
||||
} else
|
||||
# endif
|
||||
{
|
||||
pool = new MemoryPool(poolSize, hugePages);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -28,8 +28,12 @@
|
|||
#define XMRIG_VIRTUALMEMORY_H
|
||||
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include "base/tools/Object.h"
|
||||
|
||||
|
||||
#include <bitset>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <utility>
|
||||
|
||||
|
||||
|
|
@ -39,43 +43,50 @@ namespace xmrig {
|
|||
class VirtualMemory
|
||||
{
|
||||
public:
|
||||
inline VirtualMemory() {}
|
||||
VirtualMemory(size_t size, bool hugePages = true, size_t align = 64);
|
||||
XMRIG_DISABLE_COPY_MOVE_DEFAULT(VirtualMemory)
|
||||
|
||||
VirtualMemory(size_t size, bool hugePages, bool usePool, uint32_t node = 0, size_t alignSize = 64);
|
||||
~VirtualMemory();
|
||||
|
||||
inline bool isHugePages() const { return m_flags & HUGEPAGES; }
|
||||
inline bool isHugePages() const { return m_flags.test(FLAG_HUGEPAGES); }
|
||||
inline size_t size() const { return m_size; }
|
||||
inline uint8_t *scratchpad() const { return m_scratchpad; }
|
||||
|
||||
inline std::pair<size_t, size_t> hugePages() const
|
||||
{
|
||||
return std::pair<size_t, size_t>(isHugePages() ? (align(size()) / 2097152) : 0, align(size()) / 2097152);
|
||||
return { isHugePages() ? (align(size()) / 2097152) : 0, align(size()) / 2097152 };
|
||||
}
|
||||
|
||||
static bool isHugepagesAvailable();
|
||||
static uint32_t bindToNUMANode(int64_t affinity);
|
||||
static void *allocateExecutableMemory(size_t size);
|
||||
static void *allocateLargePagesMemory(size_t size);
|
||||
static void destroy();
|
||||
static void flushInstructionCache(void *p, size_t size);
|
||||
static void freeLargePagesMemory(void *p, size_t size);
|
||||
static void init(bool hugePages);
|
||||
static void init(size_t poolSize, bool hugePages);
|
||||
static void protectExecutableMemory(void *p, size_t size);
|
||||
static void unprotectExecutableMemory(void *p, size_t size);
|
||||
|
||||
static inline bool isHugepagesAvailable() { return (m_globalFlags & HUGEPAGES_AVAILABLE) != 0; }
|
||||
static inline constexpr size_t align(size_t pos, size_t align = 2097152) { return ((pos - 1) / align + 1) * align; }
|
||||
|
||||
private:
|
||||
enum Flags {
|
||||
HUGEPAGES_AVAILABLE = 1,
|
||||
HUGEPAGES = 2,
|
||||
LOCK = 4
|
||||
FLAG_HUGEPAGES,
|
||||
FLAG_LOCK,
|
||||
FLAG_EXTERNAL,
|
||||
FLAG_MAX
|
||||
};
|
||||
|
||||
static int m_globalFlags;
|
||||
static void osInit();
|
||||
|
||||
int m_flags = 0;
|
||||
size_t m_size = 0;
|
||||
uint8_t *m_scratchpad = nullptr;
|
||||
bool allocateLargePagesMemory();
|
||||
void freeLargePagesMemory();
|
||||
|
||||
const size_t m_size;
|
||||
const uint32_t m_node;
|
||||
std::bitset<FLAG_MAX> m_flags;
|
||||
uint8_t *m_scratchpad = nullptr;
|
||||
};
|
||||
|
||||
|
||||
|
|
|
|||
56
src/crypto/common/VirtualMemory_hwloc.cpp
Normal file
56
src/crypto/common/VirtualMemory_hwloc.cpp
Normal file
|
|
@ -0,0 +1,56 @@
|
|||
/* XMRig
|
||||
* Copyright 2010 Jeff Garzik <jgarzik@pobox.com>
|
||||
* Copyright 2012-2014 pooler <pooler@litecoinpool.org>
|
||||
* Copyright 2014 Lucas Jones <https://github.com/lucasjones>
|
||||
* Copyright 2014-2016 Wolf9466 <https://github.com/OhGodAPet>
|
||||
* Copyright 2016 Jay D Dee <jayddee246@gmail.com>
|
||||
* Copyright 2017-2018 XMR-Stak <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
|
||||
* Copyright 2018 Lee Clagett <https://github.com/vtnerd>
|
||||
* Copyright 2018-2019 SChernykh <https://github.com/SChernykh>
|
||||
* Copyright 2018-2019 tevador <tevador@gmail.com>
|
||||
* Copyright 2016-2019 XMRig <https://github.com/xmrig>, <support@xmrig.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
|
||||
#include "crypto/common/VirtualMemory.h"
|
||||
#include "backend/cpu/Cpu.h"
|
||||
#include "backend/cpu/platform/HwlocCpuInfo.h"
|
||||
#include "base/io/log/Log.h"
|
||||
|
||||
|
||||
#include <hwloc.h>
|
||||
|
||||
|
||||
uint32_t xmrig::VirtualMemory::bindToNUMANode(int64_t affinity)
|
||||
{
|
||||
if (affinity < 0 || Cpu::info()->nodes() < 2) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
auto cpu = static_cast<HwlocCpuInfo *>(Cpu::info());
|
||||
hwloc_obj_t pu = hwloc_get_pu_obj_by_os_index(cpu->topology(), static_cast<unsigned>(affinity));
|
||||
|
||||
char *buffer;
|
||||
hwloc_bitmap_asprintf(&buffer, pu->cpuset);
|
||||
|
||||
if (pu == nullptr || !cpu->membind(pu->nodeset)) {
|
||||
LOG_WARN("CPU #%02" PRId64 " warning: \"can't bind memory\"", affinity);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
return hwloc_bitmap_first(pu->nodeset);
|
||||
}
|
||||
|
|
@ -25,7 +25,7 @@
|
|||
*/
|
||||
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <cstdlib>
|
||||
#include <sys/mman.h>
|
||||
|
||||
|
||||
|
|
@ -38,51 +38,12 @@
|
|||
#endif
|
||||
|
||||
|
||||
int xmrig::VirtualMemory::m_globalFlags = 0;
|
||||
|
||||
|
||||
xmrig::VirtualMemory::VirtualMemory(size_t size, bool hugePages, size_t align) :
|
||||
m_size(VirtualMemory::align(size))
|
||||
bool xmrig::VirtualMemory::isHugepagesAvailable()
|
||||
{
|
||||
if (hugePages) {
|
||||
m_scratchpad = static_cast<uint8_t*>(allocateLargePagesMemory(m_size));
|
||||
if (m_scratchpad) {
|
||||
m_flags |= HUGEPAGES;
|
||||
|
||||
madvise(m_scratchpad, size, MADV_RANDOM | MADV_WILLNEED);
|
||||
|
||||
if (mlock(m_scratchpad, m_size) == 0) {
|
||||
m_flags |= LOCK;
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
m_scratchpad = static_cast<uint8_t*>(_mm_malloc(m_size, align));
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
xmrig::VirtualMemory::~VirtualMemory()
|
||||
{
|
||||
if (!m_scratchpad) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (isHugePages()) {
|
||||
if (m_flags & LOCK) {
|
||||
munlock(m_scratchpad, m_size);
|
||||
}
|
||||
|
||||
freeLargePagesMemory(m_scratchpad, m_size);
|
||||
}
|
||||
else {
|
||||
_mm_free(m_scratchpad);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void *xmrig::VirtualMemory::allocateExecutableMemory(size_t size)
|
||||
{
|
||||
# if defined(__APPLE__)
|
||||
|
|
@ -123,14 +84,6 @@ void xmrig::VirtualMemory::freeLargePagesMemory(void *p, size_t size)
|
|||
}
|
||||
|
||||
|
||||
void xmrig::VirtualMemory::init(bool hugePages)
|
||||
{
|
||||
if (hugePages) {
|
||||
m_globalFlags = HUGEPAGES | HUGEPAGES_AVAILABLE;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void xmrig::VirtualMemory::protectExecutableMemory(void *p, size_t size)
|
||||
{
|
||||
mprotect(p, size, PROT_READ | PROT_EXEC);
|
||||
|
|
@ -141,3 +94,37 @@ void xmrig::VirtualMemory::unprotectExecutableMemory(void *p, size_t size)
|
|||
{
|
||||
mprotect(p, size, PROT_WRITE | PROT_EXEC);
|
||||
}
|
||||
|
||||
|
||||
void xmrig::VirtualMemory::osInit()
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
bool xmrig::VirtualMemory::allocateLargePagesMemory()
|
||||
{
|
||||
m_scratchpad = static_cast<uint8_t*>(allocateLargePagesMemory(m_size));
|
||||
if (m_scratchpad) {
|
||||
m_flags.set(FLAG_HUGEPAGES, true);
|
||||
|
||||
madvise(m_scratchpad, m_size, MADV_RANDOM | MADV_WILLNEED);
|
||||
|
||||
if (mlock(m_scratchpad, m_size) == 0) {
|
||||
m_flags.set(FLAG_LOCK, true);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
void xmrig::VirtualMemory::freeLargePagesMemory()
|
||||
{
|
||||
if (m_flags.test(FLAG_LOCK)) {
|
||||
munlock(m_scratchpad, m_size);
|
||||
}
|
||||
|
||||
freeLargePagesMemory(m_scratchpad, m_size);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -36,6 +36,12 @@
|
|||
#include "crypto/common/VirtualMemory.h"
|
||||
|
||||
|
||||
namespace xmrig {
|
||||
|
||||
|
||||
static bool hugepagesAvailable = false;
|
||||
|
||||
|
||||
/*****************************************************************
|
||||
SetLockPagesPrivilege: a function to obtain or
|
||||
release the privilege of locking physical pages.
|
||||
|
|
@ -83,7 +89,7 @@ static BOOL SetLockPagesPrivilege() {
|
|||
static LSA_UNICODE_STRING StringToLsaUnicodeString(LPCTSTR string) {
|
||||
LSA_UNICODE_STRING lsaString;
|
||||
|
||||
DWORD dwLen = (DWORD) wcslen(string);
|
||||
const auto dwLen = (DWORD) wcslen(string);
|
||||
lsaString.Buffer = (LPWSTR) string;
|
||||
lsaString.Length = (USHORT)((dwLen) * sizeof(WCHAR));
|
||||
lsaString.MaximumLength = (USHORT)((dwLen + 1) * sizeof(WCHAR));
|
||||
|
|
@ -141,37 +147,12 @@ static BOOL TrySetLockPagesPrivilege() {
|
|||
}
|
||||
|
||||
|
||||
int xmrig::VirtualMemory::m_globalFlags = 0;
|
||||
} // namespace xmrig
|
||||
|
||||
|
||||
xmrig::VirtualMemory::VirtualMemory(size_t size, bool hugePages, size_t align) :
|
||||
m_size(VirtualMemory::align(size))
|
||||
bool xmrig::VirtualMemory::isHugepagesAvailable()
|
||||
{
|
||||
if (hugePages) {
|
||||
m_scratchpad = static_cast<uint8_t*>(allocateLargePagesMemory(m_size));
|
||||
if (m_scratchpad) {
|
||||
m_flags |= HUGEPAGES;
|
||||
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
m_scratchpad = static_cast<uint8_t*>(_mm_malloc(m_size, align));
|
||||
}
|
||||
|
||||
|
||||
xmrig::VirtualMemory::~VirtualMemory()
|
||||
{
|
||||
if (!m_scratchpad) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (isHugePages()) {
|
||||
freeLargePagesMemory(m_scratchpad, m_size);
|
||||
}
|
||||
else {
|
||||
_mm_free(m_scratchpad);
|
||||
}
|
||||
return hugepagesAvailable;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -206,20 +187,6 @@ void xmrig::VirtualMemory::freeLargePagesMemory(void *p, size_t)
|
|||
}
|
||||
|
||||
|
||||
void xmrig::VirtualMemory::init(bool hugePages)
|
||||
{
|
||||
if (!hugePages) {
|
||||
return;
|
||||
}
|
||||
|
||||
m_globalFlags = HUGEPAGES;
|
||||
|
||||
if (TrySetLockPagesPrivilege()) {
|
||||
m_globalFlags |= HUGEPAGES_AVAILABLE;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void xmrig::VirtualMemory::protectExecutableMemory(void *p, size_t size)
|
||||
{
|
||||
DWORD oldProtect;
|
||||
|
|
@ -232,3 +199,28 @@ void xmrig::VirtualMemory::unprotectExecutableMemory(void *p, size_t size)
|
|||
DWORD oldProtect;
|
||||
VirtualProtect(p, size, PAGE_EXECUTE_READWRITE, &oldProtect);
|
||||
}
|
||||
|
||||
|
||||
void xmrig::VirtualMemory::osInit()
|
||||
{
|
||||
hugepagesAvailable = TrySetLockPagesPrivilege();
|
||||
}
|
||||
|
||||
|
||||
bool xmrig::VirtualMemory::allocateLargePagesMemory()
|
||||
{
|
||||
m_scratchpad = static_cast<uint8_t*>(allocateLargePagesMemory(m_size));
|
||||
if (m_scratchpad) {
|
||||
m_flags.set(FLAG_HUGEPAGES, true);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
void xmrig::VirtualMemory::freeLargePagesMemory()
|
||||
{
|
||||
freeLargePagesMemory(m_scratchpad, m_size);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -268,8 +268,6 @@ namespace randomx {
|
|||
}
|
||||
|
||||
void JitCompilerX86::generateProgramPrologue(Program& prog, ProgramConfiguration& pcfg) {
|
||||
memset(registerUsage, -1, sizeof(registerUsage));
|
||||
|
||||
codePos = ((uint8_t*)randomx_program_prologue_first_load) - ((uint8_t*)randomx_program_prologue);
|
||||
code[codePos + 2] = 0xc0 + pcfg.readReg0;
|
||||
code[codePos + 5] = 0xc0 + pcfg.readReg1;
|
||||
|
|
@ -280,13 +278,21 @@ namespace randomx {
|
|||
memcpy(code + codePos - 48, &pcfg.eMask, sizeof(pcfg.eMask));
|
||||
memcpy(code + codePos, codeLoopLoad, loopLoadSize);
|
||||
codePos += loopLoadSize;
|
||||
for (unsigned i = 0; i < prog.getSize(); ++i) {
|
||||
Instruction& instr = prog(i);
|
||||
instr.src %= RegistersCount;
|
||||
instr.dst %= RegistersCount;
|
||||
instructionOffsets[i] = codePos;
|
||||
(this->*(engine[instr.opcode]))(instr, i);
|
||||
|
||||
//mark all registers as used
|
||||
uint64_t* r = (uint64_t*)registerUsage;
|
||||
uint64_t k = codePos;
|
||||
k |= k << 32;
|
||||
for (unsigned j = 0; j < RegistersCount / 2; ++j) {
|
||||
r[j] = k;
|
||||
}
|
||||
|
||||
for (int i = 0, n = static_cast<int>(RandomX_CurrentConfig.ProgramSize); i < n; ++i) {
|
||||
Instruction instr = prog(i);
|
||||
*((uint64_t*)&instr) &= (uint64_t(-1) - (0xFFFF << 8)) | ((RegistersCount - 1) << 8) | ((RegistersCount - 1) << 16);
|
||||
(this->*(engine[instr.opcode]))(instr);
|
||||
}
|
||||
|
||||
emit(REX_MOV_RR, code, codePos);
|
||||
emitByte(0xc0 + pcfg.readReg2, code, codePos);
|
||||
emit(REX_XOR_EAX, code, codePos);
|
||||
|
|
@ -402,7 +408,7 @@ namespace randomx {
|
|||
}
|
||||
}
|
||||
|
||||
void JitCompilerX86::genAddressReg(Instruction& instr, uint8_t* code, int& codePos, bool rax) {
|
||||
void JitCompilerX86::genAddressReg(const Instruction& instr, uint8_t* code, int& codePos, bool rax) {
|
||||
emit(LEA_32, code, codePos);
|
||||
emitByte(0x80 + instr.src + (rax ? 0 : 8), code, codePos);
|
||||
if (instr.src == RegisterNeedsSib) {
|
||||
|
|
@ -416,7 +422,7 @@ namespace randomx {
|
|||
emit32(instr.getModMem() ? ScratchpadL1Mask : ScratchpadL2Mask, code, codePos);
|
||||
}
|
||||
|
||||
void JitCompilerX86::genAddressRegDst(Instruction& instr, uint8_t* code, int& codePos) {
|
||||
void JitCompilerX86::genAddressRegDst(const Instruction& instr, uint8_t* code, int& codePos) {
|
||||
emit(LEA_32, code, codePos);
|
||||
emitByte(0x80 + instr.dst, code, codePos);
|
||||
if (instr.dst == RegisterNeedsSib) {
|
||||
|
|
@ -432,7 +438,7 @@ namespace randomx {
|
|||
}
|
||||
}
|
||||
|
||||
void JitCompilerX86::genAddressImm(Instruction& instr, uint8_t* code, int& codePos) {
|
||||
void JitCompilerX86::genAddressImm(const Instruction& instr, uint8_t* code, int& codePos) {
|
||||
emit32(instr.getImm32() & ScratchpadL3Mask, code, codePos);
|
||||
}
|
||||
|
||||
|
|
@ -447,17 +453,18 @@ namespace randomx {
|
|||
0x3c8d4f,
|
||||
};
|
||||
|
||||
void JitCompilerX86::h_IADD_RS(Instruction& instr, int i) {
|
||||
void JitCompilerX86::h_IADD_RS(const Instruction& instr) {
|
||||
int pos = codePos;
|
||||
uint8_t* const p = code + pos;
|
||||
|
||||
registerUsage[instr.dst] = i;
|
||||
|
||||
const uint32_t sib = (instr.getModShift() << 6) | (instr.src << 3) | instr.dst;
|
||||
*(uint32_t*)(p) = template_IADD_RS[instr.dst] | (sib << 24);
|
||||
*(uint32_t*)(p + 4) = instr.getImm32();
|
||||
|
||||
codePos = pos + ((instr.dst == RegisterNeedsDisplacement) ? 8 : 4);
|
||||
pos += ((instr.dst == RegisterNeedsDisplacement) ? 8 : 4);
|
||||
|
||||
registerUsage[instr.dst] = pos;
|
||||
codePos = pos;
|
||||
}
|
||||
|
||||
static const uint32_t template_IADD_M[8] = {
|
||||
|
|
@ -471,11 +478,10 @@ namespace randomx {
|
|||
0x063c034c,
|
||||
};
|
||||
|
||||
void JitCompilerX86::h_IADD_M(Instruction& instr, int i) {
|
||||
void JitCompilerX86::h_IADD_M(const Instruction& instr) {
|
||||
uint8_t* const p = code;
|
||||
int pos = codePos;
|
||||
|
||||
registerUsage[instr.dst] = i;
|
||||
if (instr.src != instr.dst) {
|
||||
genAddressReg(instr, p, pos);
|
||||
emit32(template_IADD_M[instr.dst], p, pos);
|
||||
|
|
@ -486,6 +492,7 @@ namespace randomx {
|
|||
genAddressImm(instr, p, pos);
|
||||
}
|
||||
|
||||
registerUsage[instr.dst] = pos;
|
||||
codePos = pos;
|
||||
}
|
||||
|
||||
|
|
@ -493,11 +500,10 @@ namespace randomx {
|
|||
emitByte((scale << 6) | (index << 3) | base, code, codePos);
|
||||
}
|
||||
|
||||
void JitCompilerX86::h_ISUB_R(Instruction& instr, int i) {
|
||||
void JitCompilerX86::h_ISUB_R(const Instruction& instr) {
|
||||
uint8_t* const p = code;
|
||||
int pos = codePos;
|
||||
|
||||
registerUsage[instr.dst] = i;
|
||||
if (instr.src != instr.dst) {
|
||||
emit(REX_SUB_RR, p, pos);
|
||||
emitByte(0xc0 + 8 * instr.dst + instr.src, p, pos);
|
||||
|
|
@ -508,14 +514,14 @@ namespace randomx {
|
|||
emit32(instr.getImm32(), p, pos);
|
||||
}
|
||||
|
||||
registerUsage[instr.dst] = pos;
|
||||
codePos = pos;
|
||||
}
|
||||
|
||||
void JitCompilerX86::h_ISUB_M(Instruction& instr, int i) {
|
||||
void JitCompilerX86::h_ISUB_M(const Instruction& instr) {
|
||||
uint8_t* const p = code;
|
||||
int pos = codePos;
|
||||
|
||||
registerUsage[instr.dst] = i;
|
||||
if (instr.src != instr.dst) {
|
||||
genAddressReg(instr, p, pos);
|
||||
emit(REX_SUB_RM, p, pos);
|
||||
|
|
@ -528,14 +534,14 @@ namespace randomx {
|
|||
genAddressImm(instr, p, pos);
|
||||
}
|
||||
|
||||
registerUsage[instr.dst] = pos;
|
||||
codePos = pos;
|
||||
}
|
||||
|
||||
void JitCompilerX86::h_IMUL_R(Instruction& instr, int i) {
|
||||
void JitCompilerX86::h_IMUL_R(const Instruction& instr) {
|
||||
uint8_t* const p = code;
|
||||
int pos = codePos;
|
||||
|
||||
registerUsage[instr.dst] = i;
|
||||
if (instr.src != instr.dst) {
|
||||
emit(REX_IMUL_RR, p, pos);
|
||||
emitByte(0xc0 + 8 * instr.dst + instr.src, p, pos);
|
||||
|
|
@ -546,14 +552,14 @@ namespace randomx {
|
|||
emit32(instr.getImm32(), p, pos);
|
||||
}
|
||||
|
||||
registerUsage[instr.dst] = pos;
|
||||
codePos = pos;
|
||||
}
|
||||
|
||||
void JitCompilerX86::h_IMUL_M(Instruction& instr, int i) {
|
||||
void JitCompilerX86::h_IMUL_M(const Instruction& instr) {
|
||||
uint8_t* const p = code;
|
||||
int pos = codePos;
|
||||
|
||||
registerUsage[instr.dst] = i;
|
||||
if (instr.src != instr.dst) {
|
||||
genAddressReg(instr, p, pos);
|
||||
emit(REX_IMUL_RM, p, pos);
|
||||
|
|
@ -566,14 +572,14 @@ namespace randomx {
|
|||
genAddressImm(instr, p, pos);
|
||||
}
|
||||
|
||||
registerUsage[instr.dst] = pos;
|
||||
codePos = pos;
|
||||
}
|
||||
|
||||
void JitCompilerX86::h_IMULH_R(Instruction& instr, int i) {
|
||||
void JitCompilerX86::h_IMULH_R(const Instruction& instr) {
|
||||
uint8_t* const p = code;
|
||||
int pos = codePos;
|
||||
|
||||
registerUsage[instr.dst] = i;
|
||||
emit(REX_MOV_RR64, p, pos);
|
||||
emitByte(0xc0 + instr.dst, p, pos);
|
||||
emit(REX_MUL_R, p, pos);
|
||||
|
|
@ -581,14 +587,14 @@ namespace randomx {
|
|||
emit(REX_MOV_R64R, p, pos);
|
||||
emitByte(0xc2 + 8 * instr.dst, p, pos);
|
||||
|
||||
registerUsage[instr.dst] = pos;
|
||||
codePos = pos;
|
||||
}
|
||||
|
||||
void JitCompilerX86::h_IMULH_M(Instruction& instr, int i) {
|
||||
void JitCompilerX86::h_IMULH_M(const Instruction& instr) {
|
||||
uint8_t* const p = code;
|
||||
int pos = codePos;
|
||||
|
||||
registerUsage[instr.dst] = i;
|
||||
if (instr.src != instr.dst) {
|
||||
genAddressReg(instr, p, pos, false);
|
||||
emit(REX_MOV_RR64, p, pos);
|
||||
|
|
@ -605,14 +611,14 @@ namespace randomx {
|
|||
emit(REX_MOV_R64R, p, pos);
|
||||
emitByte(0xc2 + 8 * instr.dst, p, pos);
|
||||
|
||||
registerUsage[instr.dst] = pos;
|
||||
codePos = pos;
|
||||
}
|
||||
|
||||
void JitCompilerX86::h_ISMULH_R(Instruction& instr, int i) {
|
||||
void JitCompilerX86::h_ISMULH_R(const Instruction& instr) {
|
||||
uint8_t* const p = code;
|
||||
int pos = codePos;
|
||||
|
||||
registerUsage[instr.dst] = i;
|
||||
emit(REX_MOV_RR64, p, pos);
|
||||
emitByte(0xc0 + instr.dst, p, pos);
|
||||
emit(REX_MUL_R, p, pos);
|
||||
|
|
@ -620,14 +626,14 @@ namespace randomx {
|
|||
emit(REX_MOV_R64R, p, pos);
|
||||
emitByte(0xc2 + 8 * instr.dst, p, pos);
|
||||
|
||||
registerUsage[instr.dst] = pos;
|
||||
codePos = pos;
|
||||
}
|
||||
|
||||
void JitCompilerX86::h_ISMULH_M(Instruction& instr, int i) {
|
||||
void JitCompilerX86::h_ISMULH_M(const Instruction& instr) {
|
||||
uint8_t* const p = code;
|
||||
int pos = codePos;
|
||||
|
||||
registerUsage[instr.dst] = i;
|
||||
if (instr.src != instr.dst) {
|
||||
genAddressReg(instr, p, pos, false);
|
||||
emit(REX_MOV_RR64, p, pos);
|
||||
|
|
@ -644,41 +650,41 @@ namespace randomx {
|
|||
emit(REX_MOV_R64R, p, pos);
|
||||
emitByte(0xc2 + 8 * instr.dst, p, pos);
|
||||
|
||||
registerUsage[instr.dst] = pos;
|
||||
codePos = pos;
|
||||
}
|
||||
|
||||
void JitCompilerX86::h_IMUL_RCP(Instruction& instr, int i) {
|
||||
void JitCompilerX86::h_IMUL_RCP(const Instruction& instr) {
|
||||
uint8_t* const p = code;
|
||||
int pos = codePos;
|
||||
|
||||
uint64_t divisor = instr.getImm32();
|
||||
if (!isZeroOrPowerOf2(divisor)) {
|
||||
registerUsage[instr.dst] = i;
|
||||
emit(MOV_RAX_I, p, pos);
|
||||
emit64(randomx_reciprocal_fast(divisor), p, pos);
|
||||
emit(REX_IMUL_RM, p, pos);
|
||||
emitByte(0xc0 + 8 * instr.dst, p, pos);
|
||||
registerUsage[instr.dst] = pos;
|
||||
}
|
||||
|
||||
codePos = pos;
|
||||
}
|
||||
|
||||
void JitCompilerX86::h_INEG_R(Instruction& instr, int i) {
|
||||
void JitCompilerX86::h_INEG_R(const Instruction& instr) {
|
||||
uint8_t* const p = code;
|
||||
int pos = codePos;
|
||||
|
||||
registerUsage[instr.dst] = i;
|
||||
emit(REX_NEG, p, pos);
|
||||
emitByte(0xd8 + instr.dst, p, pos);
|
||||
|
||||
registerUsage[instr.dst] = pos;
|
||||
codePos = pos;
|
||||
}
|
||||
|
||||
void JitCompilerX86::h_IXOR_R(Instruction& instr, int i) {
|
||||
void JitCompilerX86::h_IXOR_R(const Instruction& instr) {
|
||||
uint8_t* const p = code;
|
||||
int pos = codePos;
|
||||
|
||||
registerUsage[instr.dst] = i;
|
||||
if (instr.src != instr.dst) {
|
||||
emit(REX_XOR_RR, p, pos);
|
||||
emitByte(0xc0 + 8 * instr.dst + instr.src, p, pos);
|
||||
|
|
@ -689,14 +695,14 @@ namespace randomx {
|
|||
emit32(instr.getImm32(), p, pos);
|
||||
}
|
||||
|
||||
registerUsage[instr.dst] = pos;
|
||||
codePos = pos;
|
||||
}
|
||||
|
||||
void JitCompilerX86::h_IXOR_M(Instruction& instr, int i) {
|
||||
void JitCompilerX86::h_IXOR_M(const Instruction& instr) {
|
||||
uint8_t* const p = code;
|
||||
int pos = codePos;
|
||||
|
||||
registerUsage[instr.dst] = i;
|
||||
if (instr.src != instr.dst) {
|
||||
genAddressReg(instr, p, pos);
|
||||
emit(REX_XOR_RM, p, pos);
|
||||
|
|
@ -709,14 +715,14 @@ namespace randomx {
|
|||
genAddressImm(instr, p, pos);
|
||||
}
|
||||
|
||||
registerUsage[instr.dst] = pos;
|
||||
codePos = pos;
|
||||
}
|
||||
|
||||
void JitCompilerX86::h_IROR_R(Instruction& instr, int i) {
|
||||
void JitCompilerX86::h_IROR_R(const Instruction& instr) {
|
||||
uint8_t* const p = code;
|
||||
int pos = codePos;
|
||||
|
||||
registerUsage[instr.dst] = i;
|
||||
if (instr.src != instr.dst) {
|
||||
emit(REX_MOV_RR, p, pos);
|
||||
emitByte(0xc8 + instr.src, p, pos);
|
||||
|
|
@ -729,14 +735,14 @@ namespace randomx {
|
|||
emitByte(instr.getImm32() & 63, p, pos);
|
||||
}
|
||||
|
||||
registerUsage[instr.dst] = pos;
|
||||
codePos = pos;
|
||||
}
|
||||
|
||||
void JitCompilerX86::h_IROL_R(Instruction& instr, int i) {
|
||||
void JitCompilerX86::h_IROL_R(const Instruction& instr) {
|
||||
uint8_t* const p = code;
|
||||
int pos = codePos;
|
||||
|
||||
registerUsage[instr.dst] = i;
|
||||
if (instr.src != instr.dst) {
|
||||
emit(REX_MOV_RR, p, pos);
|
||||
emitByte(0xc8 + instr.src, p, pos);
|
||||
|
|
@ -749,24 +755,25 @@ namespace randomx {
|
|||
emitByte(instr.getImm32() & 63, p, pos);
|
||||
}
|
||||
|
||||
registerUsage[instr.dst] = pos;
|
||||
codePos = pos;
|
||||
}
|
||||
|
||||
void JitCompilerX86::h_ISWAP_R(Instruction& instr, int i) {
|
||||
void JitCompilerX86::h_ISWAP_R(const Instruction& instr) {
|
||||
uint8_t* const p = code;
|
||||
int pos = codePos;
|
||||
|
||||
if (instr.src != instr.dst) {
|
||||
registerUsage[instr.dst] = i;
|
||||
registerUsage[instr.src] = i;
|
||||
emit(REX_XCHG, p, pos);
|
||||
emitByte(0xc0 + instr.src + 8 * instr.dst, p, pos);
|
||||
registerUsage[instr.dst] = pos;
|
||||
registerUsage[instr.src] = pos;
|
||||
}
|
||||
|
||||
codePos = pos;
|
||||
}
|
||||
|
||||
void JitCompilerX86::h_FSWAP_R(Instruction& instr, int i) {
|
||||
void JitCompilerX86::h_FSWAP_R(const Instruction& instr) {
|
||||
uint8_t* const p = code;
|
||||
int pos = codePos;
|
||||
|
||||
|
|
@ -777,105 +784,105 @@ namespace randomx {
|
|||
codePos = pos;
|
||||
}
|
||||
|
||||
void JitCompilerX86::h_FADD_R(Instruction& instr, int i) {
|
||||
void JitCompilerX86::h_FADD_R(const Instruction& instr) {
|
||||
uint8_t* const p = code;
|
||||
int pos = codePos;
|
||||
|
||||
instr.dst %= RegisterCountFlt;
|
||||
instr.src %= RegisterCountFlt;
|
||||
const uint32_t dst = instr.dst % RegisterCountFlt;
|
||||
const uint32_t src = instr.src % RegisterCountFlt;
|
||||
emit(REX_ADDPD, p, pos);
|
||||
emitByte(0xc0 + instr.src + 8 * instr.dst, p, pos);
|
||||
emitByte(0xc0 + src + 8 * dst, p, pos);
|
||||
|
||||
codePos = pos;
|
||||
}
|
||||
|
||||
void JitCompilerX86::h_FADD_M(Instruction& instr, int i) {
|
||||
void JitCompilerX86::h_FADD_M(const Instruction& instr) {
|
||||
uint8_t* const p = code;
|
||||
int pos = codePos;
|
||||
|
||||
instr.dst %= RegisterCountFlt;
|
||||
const uint32_t dst = instr.dst % RegisterCountFlt;
|
||||
genAddressReg(instr, p, pos);
|
||||
emit(REX_CVTDQ2PD_XMM12, p, pos);
|
||||
emit(REX_ADDPD, p, pos);
|
||||
emitByte(0xc4 + 8 * instr.dst, p, pos);
|
||||
emitByte(0xc4 + 8 * dst, p, pos);
|
||||
|
||||
codePos = pos;
|
||||
}
|
||||
|
||||
void JitCompilerX86::h_FSUB_R(Instruction& instr, int i) {
|
||||
void JitCompilerX86::h_FSUB_R(const Instruction& instr) {
|
||||
uint8_t* const p = code;
|
||||
int pos = codePos;
|
||||
|
||||
instr.dst %= RegisterCountFlt;
|
||||
instr.src %= RegisterCountFlt;
|
||||
const uint32_t dst = instr.dst % RegisterCountFlt;
|
||||
const uint32_t src = instr.src % RegisterCountFlt;
|
||||
emit(REX_SUBPD, p, pos);
|
||||
emitByte(0xc0 + instr.src + 8 * instr.dst, p, pos);
|
||||
emitByte(0xc0 + src + 8 * dst, p, pos);
|
||||
|
||||
codePos = pos;
|
||||
}
|
||||
|
||||
void JitCompilerX86::h_FSUB_M(Instruction& instr, int i) {
|
||||
void JitCompilerX86::h_FSUB_M(const Instruction& instr) {
|
||||
uint8_t* const p = code;
|
||||
int pos = codePos;
|
||||
|
||||
instr.dst %= RegisterCountFlt;
|
||||
const uint32_t dst = instr.dst % RegisterCountFlt;
|
||||
genAddressReg(instr, p, pos);
|
||||
emit(REX_CVTDQ2PD_XMM12, p, pos);
|
||||
emit(REX_SUBPD, p, pos);
|
||||
emitByte(0xc4 + 8 * instr.dst, p, pos);
|
||||
emitByte(0xc4 + 8 * dst, p, pos);
|
||||
|
||||
codePos = pos;
|
||||
}
|
||||
|
||||
void JitCompilerX86::h_FSCAL_R(Instruction& instr, int i) {
|
||||
void JitCompilerX86::h_FSCAL_R(const Instruction& instr) {
|
||||
uint8_t* const p = code;
|
||||
int pos = codePos;
|
||||
|
||||
instr.dst %= RegisterCountFlt;
|
||||
const uint32_t dst = instr.dst % RegisterCountFlt;
|
||||
emit(REX_XORPS, p, pos);
|
||||
emitByte(0xc7 + 8 * instr.dst, p, pos);
|
||||
emitByte(0xc7 + 8 * dst, p, pos);
|
||||
|
||||
codePos = pos;
|
||||
}
|
||||
|
||||
void JitCompilerX86::h_FMUL_R(Instruction& instr, int i) {
|
||||
void JitCompilerX86::h_FMUL_R(const Instruction& instr) {
|
||||
uint8_t* const p = code;
|
||||
int pos = codePos;
|
||||
|
||||
instr.dst %= RegisterCountFlt;
|
||||
instr.src %= RegisterCountFlt;
|
||||
const uint32_t dst = instr.dst % RegisterCountFlt;
|
||||
const uint32_t src = instr.src % RegisterCountFlt;
|
||||
emit(REX_MULPD, p, pos);
|
||||
emitByte(0xe0 + instr.src + 8 * instr.dst, p, pos);
|
||||
emitByte(0xe0 + src + 8 * dst, p, pos);
|
||||
|
||||
codePos = pos;
|
||||
}
|
||||
|
||||
void JitCompilerX86::h_FDIV_M(Instruction& instr, int i) {
|
||||
void JitCompilerX86::h_FDIV_M(const Instruction& instr) {
|
||||
uint8_t* const p = code;
|
||||
int pos = codePos;
|
||||
|
||||
instr.dst %= RegisterCountFlt;
|
||||
const uint32_t dst = instr.dst % RegisterCountFlt;
|
||||
genAddressReg(instr, p, pos);
|
||||
emit(REX_CVTDQ2PD_XMM12, p, pos);
|
||||
emit(REX_ANDPS_XMM12, p, pos);
|
||||
emit(REX_DIVPD, p, pos);
|
||||
emitByte(0xe4 + 8 * instr.dst, p, pos);
|
||||
emitByte(0xe4 + 8 * dst, p, pos);
|
||||
|
||||
codePos = pos;
|
||||
}
|
||||
|
||||
void JitCompilerX86::h_FSQRT_R(Instruction& instr, int i) {
|
||||
void JitCompilerX86::h_FSQRT_R(const Instruction& instr) {
|
||||
uint8_t* const p = code;
|
||||
int pos = codePos;
|
||||
|
||||
instr.dst %= RegisterCountFlt;
|
||||
const uint32_t dst = instr.dst % RegisterCountFlt;
|
||||
emit(SQRTPD, p, pos);
|
||||
emitByte(0xe4 + 9 * instr.dst, p, pos);
|
||||
emitByte(0xe4 + 9 * dst, p, pos);
|
||||
|
||||
codePos = pos;
|
||||
}
|
||||
|
||||
void JitCompilerX86::h_CFROUND(Instruction& instr, int i) {
|
||||
void JitCompilerX86::h_CFROUND(const Instruction& instr) {
|
||||
uint8_t* const p = code;
|
||||
int pos = codePos;
|
||||
|
||||
|
|
@ -891,12 +898,11 @@ namespace randomx {
|
|||
codePos = pos;
|
||||
}
|
||||
|
||||
void JitCompilerX86::h_CBRANCH(Instruction& instr, int i) {
|
||||
void JitCompilerX86::h_CBRANCH(const Instruction& instr) {
|
||||
uint8_t* const p = code;
|
||||
int pos = codePos;
|
||||
|
||||
int reg = instr.dst;
|
||||
int target = registerUsage[reg] + 1;
|
||||
emit(REX_ADD_I, p, pos);
|
||||
emitByte(0xc0 + reg, p, pos);
|
||||
int shift = instr.getModCond() + RandomX_CurrentConfig.JumpOffset;
|
||||
|
|
@ -908,10 +914,10 @@ namespace randomx {
|
|||
emitByte(0xc0 + reg, p, pos);
|
||||
emit32(RandomX_CurrentConfig.ConditionMask_Calculated << shift, p, pos);
|
||||
emit(JZ, p, pos);
|
||||
emit32(instructionOffsets[target] - (pos + 4), p, pos);
|
||||
emit32(registerUsage[reg] - (pos + 4), p, pos);
|
||||
//mark all registers as used
|
||||
uint64_t* r = (uint64_t*) registerUsage;
|
||||
uint64_t k = i;
|
||||
uint64_t k = pos;
|
||||
k |= k << 32;
|
||||
for (unsigned j = 0; j < RegistersCount / 2; ++j) {
|
||||
r[j] = k;
|
||||
|
|
@ -920,7 +926,7 @@ namespace randomx {
|
|||
codePos = pos;
|
||||
}
|
||||
|
||||
void JitCompilerX86::h_ISTORE(Instruction& instr, int i) {
|
||||
void JitCompilerX86::h_ISTORE(const Instruction& instr) {
|
||||
uint8_t* const p = code;
|
||||
int pos = codePos;
|
||||
|
||||
|
|
@ -932,7 +938,7 @@ namespace randomx {
|
|||
codePos = pos;
|
||||
}
|
||||
|
||||
void JitCompilerX86::h_NOP(Instruction& instr, int i) {
|
||||
void JitCompilerX86::h_NOP(const Instruction& instr) {
|
||||
emit(NOP1, code, codePos);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -41,7 +41,7 @@ namespace randomx {
|
|||
class JitCompilerX86;
|
||||
class Instruction;
|
||||
|
||||
typedef void(JitCompilerX86::*InstructionGeneratorX86)(Instruction&, int);
|
||||
typedef void(JitCompilerX86::*InstructionGeneratorX86)(const Instruction&);
|
||||
|
||||
constexpr uint32_t CodeSize = 64 * 1024;
|
||||
|
||||
|
|
@ -66,16 +66,15 @@ namespace randomx {
|
|||
size_t getCodeSize();
|
||||
|
||||
static InstructionGeneratorX86 engine[256];
|
||||
int32_t instructionOffsets[512];
|
||||
int registerUsage[RegistersCount];
|
||||
uint8_t* code;
|
||||
int32_t codePos;
|
||||
|
||||
void generateProgramPrologue(Program&, ProgramConfiguration&);
|
||||
void generateProgramEpilogue(Program&, ProgramConfiguration&);
|
||||
static void genAddressReg(Instruction&, uint8_t* code, int& codePos, bool rax = true);
|
||||
static void genAddressRegDst(Instruction&, uint8_t* code, int& codePos);
|
||||
static void genAddressImm(Instruction&, uint8_t* code, int& codePos);
|
||||
static void genAddressReg(const Instruction&, uint8_t* code, int& codePos, bool rax = true);
|
||||
static void genAddressRegDst(const Instruction&, uint8_t* code, int& codePos);
|
||||
static void genAddressImm(const Instruction&, uint8_t* code, int& codePos);
|
||||
static void genSIB(int scale, int index, int base, uint8_t* code, int& codePos);
|
||||
|
||||
void generateSuperscalarCode(Instruction &, std::vector<uint64_t> &);
|
||||
|
|
@ -105,36 +104,36 @@ namespace randomx {
|
|||
codePos += count;
|
||||
}
|
||||
|
||||
void h_IADD_RS(Instruction&, int);
|
||||
void h_IADD_M(Instruction&, int);
|
||||
void h_ISUB_R(Instruction&, int);
|
||||
void h_ISUB_M(Instruction&, int);
|
||||
void h_IMUL_R(Instruction&, int);
|
||||
void h_IMUL_M(Instruction&, int);
|
||||
void h_IMULH_R(Instruction&, int);
|
||||
void h_IMULH_M(Instruction&, int);
|
||||
void h_ISMULH_R(Instruction&, int);
|
||||
void h_ISMULH_M(Instruction&, int);
|
||||
void h_IMUL_RCP(Instruction&, int);
|
||||
void h_INEG_R(Instruction&, int);
|
||||
void h_IXOR_R(Instruction&, int);
|
||||
void h_IXOR_M(Instruction&, int);
|
||||
void h_IROR_R(Instruction&, int);
|
||||
void h_IROL_R(Instruction&, int);
|
||||
void h_ISWAP_R(Instruction&, int);
|
||||
void h_FSWAP_R(Instruction&, int);
|
||||
void h_FADD_R(Instruction&, int);
|
||||
void h_FADD_M(Instruction&, int);
|
||||
void h_FSUB_R(Instruction&, int);
|
||||
void h_FSUB_M(Instruction&, int);
|
||||
void h_FSCAL_R(Instruction&, int);
|
||||
void h_FMUL_R(Instruction&, int);
|
||||
void h_FDIV_M(Instruction&, int);
|
||||
void h_FSQRT_R(Instruction&, int);
|
||||
void h_CBRANCH(Instruction&, int);
|
||||
void h_CFROUND(Instruction&, int);
|
||||
void h_ISTORE(Instruction&, int);
|
||||
void h_NOP(Instruction&, int);
|
||||
void h_IADD_RS(const Instruction&);
|
||||
void h_IADD_M(const Instruction&);
|
||||
void h_ISUB_R(const Instruction&);
|
||||
void h_ISUB_M(const Instruction&);
|
||||
void h_IMUL_R(const Instruction&);
|
||||
void h_IMUL_M(const Instruction&);
|
||||
void h_IMULH_R(const Instruction&);
|
||||
void h_IMULH_M(const Instruction&);
|
||||
void h_ISMULH_R(const Instruction&);
|
||||
void h_ISMULH_M(const Instruction&);
|
||||
void h_IMUL_RCP(const Instruction&);
|
||||
void h_INEG_R(const Instruction&);
|
||||
void h_IXOR_R(const Instruction&);
|
||||
void h_IXOR_M(const Instruction&);
|
||||
void h_IROR_R(const Instruction&);
|
||||
void h_IROL_R(const Instruction&);
|
||||
void h_ISWAP_R(const Instruction&);
|
||||
void h_FSWAP_R(const Instruction&);
|
||||
void h_FADD_R(const Instruction&);
|
||||
void h_FADD_M(const Instruction&);
|
||||
void h_FSUB_R(const Instruction&);
|
||||
void h_FSUB_M(const Instruction&);
|
||||
void h_FSCAL_R(const Instruction&);
|
||||
void h_FMUL_R(const Instruction&);
|
||||
void h_FDIV_M(const Instruction&);
|
||||
void h_FSQRT_R(const Instruction&);
|
||||
void h_CBRANCH(const Instruction&);
|
||||
void h_CFROUND(const Instruction&);
|
||||
void h_ISTORE(const Instruction&);
|
||||
void h_NOP(const Instruction&);
|
||||
};
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -82,6 +82,16 @@ RandomX_ConfigurationLoki::RandomX_ConfigurationLoki()
|
|||
RANDOMX_FREQ_CBRANCH = 16;
|
||||
}
|
||||
|
||||
RandomX_ConfigurationArqma::RandomX_ConfigurationArqma()
|
||||
{
|
||||
ArgonIterations = 1;
|
||||
ArgonSalt = "RandomARQ\x01";
|
||||
ProgramIterations = 1024;
|
||||
ProgramCount = 4;
|
||||
ScratchpadL2_Size = 131072;
|
||||
ScratchpadL3_Size = 262144;
|
||||
}
|
||||
|
||||
RandomX_ConfigurationBase::RandomX_ConfigurationBase()
|
||||
: ArgonMemory(262144)
|
||||
, ArgonIterations(3)
|
||||
|
|
@ -248,6 +258,7 @@ void RandomX_ConfigurationBase::Apply()
|
|||
RandomX_ConfigurationMonero RandomX_MoneroConfig;
|
||||
RandomX_ConfigurationWownero RandomX_WowneroConfig;
|
||||
RandomX_ConfigurationLoki RandomX_LokiConfig;
|
||||
RandomX_ConfigurationArqma RandomX_ArqmaConfig;
|
||||
|
||||
RandomX_ConfigurationBase RandomX_CurrentConfig;
|
||||
|
||||
|
|
|
|||
|
|
@ -176,10 +176,12 @@ struct RandomX_ConfigurationBase
|
|||
struct RandomX_ConfigurationMonero : public RandomX_ConfigurationBase {};
|
||||
struct RandomX_ConfigurationWownero : public RandomX_ConfigurationBase { RandomX_ConfigurationWownero(); };
|
||||
struct RandomX_ConfigurationLoki : public RandomX_ConfigurationBase { RandomX_ConfigurationLoki(); };
|
||||
struct RandomX_ConfigurationArqma : public RandomX_ConfigurationBase { RandomX_ConfigurationArqma(); };
|
||||
|
||||
extern RandomX_ConfigurationMonero RandomX_MoneroConfig;
|
||||
extern RandomX_ConfigurationWownero RandomX_WowneroConfig;
|
||||
extern RandomX_ConfigurationLoki RandomX_LokiConfig;
|
||||
extern RandomX_ConfigurationArqma RandomX_ArqmaConfig;
|
||||
|
||||
extern RandomX_ConfigurationBase RandomX_CurrentConfig;
|
||||
|
||||
|
|
|
|||
|
|
@ -26,32 +26,10 @@
|
|||
|
||||
|
||||
#include "crypto/rx/Rx.h"
|
||||
|
||||
#include "backend/common/interfaces/IRxListener.h"
|
||||
#include "backend/cpu/Cpu.h"
|
||||
#include "backend/common/Tags.h"
|
||||
#include "base/io/log/Log.h"
|
||||
#include "base/kernel/Platform.h"
|
||||
#include "base/net/stratum/Job.h"
|
||||
#include "base/tools/Buffer.h"
|
||||
#include "base/tools/Chrono.h"
|
||||
#include "base/tools/Handle.h"
|
||||
#include "base/tools/Object.h"
|
||||
#include "crypto/rx/RxAlgo.h"
|
||||
#include "crypto/rx/RxCache.h"
|
||||
#include "crypto/rx/RxDataset.h"
|
||||
|
||||
|
||||
#ifdef XMRIG_FEATURE_HWLOC
|
||||
# include <hwloc.h>
|
||||
# include "backend/cpu/platform/HwlocCpuInfo.h"
|
||||
#endif
|
||||
|
||||
|
||||
#include <atomic>
|
||||
#include <map>
|
||||
#include <mutex>
|
||||
#include <thread>
|
||||
#include <uv.h>
|
||||
#include "crypto/rx/RxConfig.h"
|
||||
#include "crypto/rx/RxQueue.h"
|
||||
|
||||
|
||||
namespace xmrig {
|
||||
|
|
@ -62,239 +40,37 @@ class RxPrivate;
|
|||
|
||||
static const char *tag = BLUE_BG(WHITE_BOLD_S " rx ") " ";
|
||||
static RxPrivate *d_ptr = nullptr;
|
||||
static std::mutex mutex;
|
||||
|
||||
|
||||
#ifdef XMRIG_FEATURE_HWLOC
|
||||
static void bindToNUMANode(uint32_t nodeId)
|
||||
{
|
||||
hwloc_topology_t topology;
|
||||
hwloc_topology_init(&topology);
|
||||
hwloc_topology_load(topology);
|
||||
|
||||
hwloc_obj_t node = hwloc_get_numanode_obj_by_os_index(topology, nodeId);
|
||||
if (node) {
|
||||
if (HwlocCpuInfo::has(HwlocCpuInfo::SET_THISTHREAD_MEMBIND)) {
|
||||
# if HWLOC_API_VERSION >= 0x20000
|
||||
hwloc_set_membind(topology, node->nodeset, HWLOC_MEMBIND_BIND, HWLOC_MEMBIND_THREAD | HWLOC_MEMBIND_BYNODESET);
|
||||
# else
|
||||
hwloc_set_membind_nodeset(topology, node->nodeset, HWLOC_MEMBIND_BIND, HWLOC_MEMBIND_THREAD);
|
||||
# endif
|
||||
}
|
||||
|
||||
Platform::setThreadAffinity(static_cast<uint64_t>(hwloc_bitmap_first(node->cpuset)));
|
||||
}
|
||||
|
||||
hwloc_topology_destroy(topology);
|
||||
}
|
||||
#else
|
||||
inline static void bindToNUMANode(uint32_t) {}
|
||||
#endif
|
||||
|
||||
|
||||
class RxPrivate
|
||||
{
|
||||
public:
|
||||
XMRIG_DISABLE_COPY_MOVE(RxPrivate)
|
||||
inline RxPrivate(IRxListener *listener) : queue(listener) {}
|
||||
|
||||
inline RxPrivate() :
|
||||
m_counter(0),
|
||||
m_last(0)
|
||||
{
|
||||
m_async = new uv_async_t;
|
||||
m_async->data = this;
|
||||
|
||||
uv_async_init(uv_default_loop(), m_async, [](uv_async_t *) { d_ptr->onReady(); });
|
||||
|
||||
# ifdef XMRIG_FEATURE_HWLOC
|
||||
if (Cpu::info()->nodes() > 1) {
|
||||
for (uint32_t nodeId : HwlocCpuInfo::nodeIndexes()) {
|
||||
datasets.insert({ nodeId, nullptr });
|
||||
}
|
||||
}
|
||||
else
|
||||
# endif
|
||||
{
|
||||
datasets.insert({ 0, nullptr });
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
inline ~RxPrivate()
|
||||
{
|
||||
Handle::close(m_async);
|
||||
|
||||
for (auto const &item : datasets) {
|
||||
delete item.second;
|
||||
}
|
||||
|
||||
datasets.clear();
|
||||
}
|
||||
|
||||
|
||||
inline bool isNUMA() const { return m_numa; }
|
||||
inline bool isReady(const Job &job) const { return m_ready == count() && m_algorithm == job.algorithm() && m_seed == job.seed(); }
|
||||
inline const Algorithm &algorithm() const { return m_algorithm; }
|
||||
inline const Buffer &seed() const { return m_seed; }
|
||||
inline size_t count() const { return isNUMA() ? datasets.size() : 1; }
|
||||
inline uint64_t counter() { return m_counter.load(std::memory_order_relaxed); }
|
||||
inline void asyncSend(uint64_t counter) { m_ready++; if (m_ready == count()) { m_last = counter; uv_async_send(m_async); } }
|
||||
|
||||
static void allocate(uint32_t nodeId)
|
||||
{
|
||||
const uint64_t ts = Chrono::steadyMSecs();
|
||||
|
||||
if (d_ptr->isNUMA()) {
|
||||
bindToNUMANode(nodeId);
|
||||
}
|
||||
|
||||
LOG_INFO("%s" CYAN_BOLD("#%u") MAGENTA_BOLD(" allocate") CYAN_BOLD(" %zu MB") BLACK_BOLD(" (%zu+%zu) for RandomX dataset & cache"),
|
||||
tag,
|
||||
nodeId,
|
||||
(RxDataset::maxSize() + RxCache::maxSize()) / 1024 / 1024,
|
||||
RxDataset::maxSize() / 1024 / 1024,
|
||||
RxCache::maxSize() / 1024 / 1024
|
||||
);
|
||||
|
||||
auto dataset = new RxDataset(d_ptr->m_hugePages);
|
||||
d_ptr->datasets[nodeId] = dataset;
|
||||
|
||||
if (dataset->get() != nullptr) {
|
||||
const auto hugePages = dataset->hugePages();
|
||||
const double percent = hugePages.first == 0 ? 0.0 : static_cast<double>(hugePages.first) / hugePages.second * 100.0;
|
||||
|
||||
LOG_INFO("%s" CYAN_BOLD("#%u") GREEN(" allocate done") " huge pages %s%u/%u %1.0f%%" CLEAR " %sJIT" BLACK_BOLD(" (%" PRIu64 " ms)"),
|
||||
tag,
|
||||
nodeId,
|
||||
(hugePages.first == hugePages.second ? GREEN_BOLD_S : (hugePages.first == 0 ? RED_BOLD_S : YELLOW_BOLD_S)),
|
||||
hugePages.first,
|
||||
hugePages.second,
|
||||
percent,
|
||||
dataset->cache()->isJIT() ? GREEN_BOLD_S "+" : RED_BOLD_S "-",
|
||||
Chrono::steadyMSecs() - ts
|
||||
);
|
||||
}
|
||||
else {
|
||||
LOG_WARN(CLEAR "%s" CYAN_BOLD("#%u") YELLOW_BOLD_S " failed to allocate RandomX dataset, switching to slow mode", tag, nodeId);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void initDataset(uint32_t nodeId, uint32_t threads, uint64_t counter)
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
|
||||
const uint64_t ts = Chrono::steadyMSecs();
|
||||
|
||||
d_ptr->getOrAllocate(nodeId)->init(d_ptr->seed(), threads);
|
||||
d_ptr->asyncSend(counter);
|
||||
|
||||
LOG_INFO("%s" CYAN_BOLD("#%u") GREEN(" init done ") CYAN_BOLD("%zu/%zu") BLACK_BOLD(" (%" PRIu64 " ms)"), tag, nodeId, d_ptr->m_ready, d_ptr->count(), Chrono::steadyMSecs() - ts);
|
||||
}
|
||||
|
||||
|
||||
inline RxDataset *getOrAllocate(uint32_t nodeId)
|
||||
{
|
||||
RxDataset *dataset = datasets.at(nodeId);
|
||||
|
||||
if (dataset == nullptr) {
|
||||
# ifdef XMRIG_FEATURE_HWLOC
|
||||
if (d_ptr->isNUMA()) {
|
||||
std::thread thread(allocate, nodeId);
|
||||
thread.join();
|
||||
} else
|
||||
# endif
|
||||
{
|
||||
allocate(nodeId);
|
||||
}
|
||||
|
||||
dataset = datasets.at(nodeId);
|
||||
}
|
||||
|
||||
return dataset;
|
||||
}
|
||||
|
||||
|
||||
inline void setState(const Job &job, bool hugePages, bool numa, IRxListener *listener)
|
||||
{
|
||||
if (m_algorithm != job.algorithm()) {
|
||||
m_algorithm = RxAlgo::apply(job.algorithm());
|
||||
}
|
||||
|
||||
m_ready = 0;
|
||||
m_numa = numa && Cpu::info()->nodes() > 1;
|
||||
m_hugePages = hugePages;
|
||||
m_listener = listener;
|
||||
m_seed = job.seed();
|
||||
|
||||
++m_counter;
|
||||
}
|
||||
|
||||
|
||||
std::map<uint32_t, RxDataset *> datasets;
|
||||
|
||||
private:
|
||||
inline void onReady()
|
||||
{
|
||||
if (m_listener && counter() == m_last.load(std::memory_order_relaxed)) {
|
||||
m_listener->onDatasetReady();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Algorithm m_algorithm;
|
||||
bool m_hugePages = true;
|
||||
bool m_numa = true;
|
||||
Buffer m_seed;
|
||||
IRxListener *m_listener = nullptr;
|
||||
size_t m_ready = 0;
|
||||
std::atomic<uint64_t> m_counter;
|
||||
std::atomic<uint64_t> m_last;
|
||||
uv_async_t *m_async = nullptr;
|
||||
RxQueue queue;
|
||||
};
|
||||
|
||||
|
||||
} // namespace xmrig
|
||||
|
||||
|
||||
bool xmrig::Rx::init(const Job &job, int initThreads, bool hugePages, bool numa, IRxListener *listener)
|
||||
const char *xmrig::rx_tag()
|
||||
{
|
||||
return tag;
|
||||
}
|
||||
|
||||
|
||||
bool xmrig::Rx::init(const Job &job, const RxConfig &config, bool hugePages)
|
||||
{
|
||||
if (job.algorithm().family() != Algorithm::RANDOM_X) {
|
||||
return true;
|
||||
}
|
||||
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
|
||||
if (d_ptr->isReady(job)) {
|
||||
if (isReady(job)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
d_ptr->setState(job, hugePages, numa, listener);
|
||||
const uint32_t threads = initThreads < 1 ? static_cast<uint32_t>(Cpu::info()->threads()) : static_cast<uint32_t>(initThreads);
|
||||
const String buf = Buffer::toHex(job.seed().data(), 8);
|
||||
const uint64_t counter = d_ptr->counter();
|
||||
|
||||
LOG_INFO("%s" MAGENTA_BOLD("init dataset%s") " algo " WHITE_BOLD("%s (") CYAN_BOLD("%u") WHITE_BOLD(" threads)") BLACK_BOLD(" seed %s..."),
|
||||
tag,
|
||||
d_ptr->count() > 1 ? "s" : "",
|
||||
job.algorithm().shortName(),
|
||||
threads,
|
||||
buf.data()
|
||||
);
|
||||
|
||||
# ifdef XMRIG_FEATURE_HWLOC
|
||||
if (d_ptr->isNUMA()) {
|
||||
for (auto const &item : d_ptr->datasets) {
|
||||
std::thread thread(RxPrivate::initDataset, item.first, threads, counter);
|
||||
thread.detach();
|
||||
}
|
||||
}
|
||||
else
|
||||
# endif
|
||||
{
|
||||
std::thread thread(RxPrivate::initDataset, 0, threads, counter);
|
||||
thread.detach();
|
||||
}
|
||||
d_ptr->queue.enqueue(job, config.nodeset(), config.threads(), hugePages);
|
||||
|
||||
return false;
|
||||
}
|
||||
|
|
@ -302,43 +78,19 @@ bool xmrig::Rx::init(const Job &job, int initThreads, bool hugePages, bool numa,
|
|||
|
||||
bool xmrig::Rx::isReady(const Job &job)
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
|
||||
return d_ptr->isReady(job);
|
||||
return d_ptr->queue.isReady(job);
|
||||
}
|
||||
|
||||
|
||||
xmrig::RxDataset *xmrig::Rx::dataset(const Job &job, uint32_t nodeId)
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
if (!d_ptr->isReady(job)) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
#ifdef XMRIG_FEATURE_HWLOC
|
||||
return d_ptr->datasets.at(d_ptr->isNUMA() ? (d_ptr->datasets.count(nodeId) ? nodeId : HwlocCpuInfo::nodeIndexes().front()) : 0);
|
||||
#else
|
||||
return d_ptr->datasets.at(0);
|
||||
#endif
|
||||
return d_ptr->queue.dataset(job, nodeId);
|
||||
}
|
||||
|
||||
|
||||
std::pair<unsigned, unsigned> xmrig::Rx::hugePages()
|
||||
std::pair<uint32_t, uint32_t> xmrig::Rx::hugePages()
|
||||
{
|
||||
std::pair<unsigned, unsigned> pages(0, 0);
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
|
||||
for (auto const &item : d_ptr->datasets) {
|
||||
if (!item.second) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const auto p = item.second->hugePages();
|
||||
pages.first += p.first;
|
||||
pages.second += p.second;
|
||||
}
|
||||
|
||||
return pages;
|
||||
return d_ptr->queue.hugePages();
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -350,7 +102,7 @@ void xmrig::Rx::destroy()
|
|||
}
|
||||
|
||||
|
||||
void xmrig::Rx::init()
|
||||
void xmrig::Rx::init(IRxListener *listener)
|
||||
{
|
||||
d_ptr = new RxPrivate();
|
||||
d_ptr = new RxPrivate(listener);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -39,18 +39,19 @@ namespace xmrig
|
|||
class Algorithm;
|
||||
class IRxListener;
|
||||
class Job;
|
||||
class RxConfig;
|
||||
class RxDataset;
|
||||
|
||||
|
||||
class Rx
|
||||
{
|
||||
public:
|
||||
static bool init(const Job &job, int initThreads, bool hugePages, bool numa, IRxListener *listener);
|
||||
static bool init(const Job &job, const RxConfig &config, bool hugePages);
|
||||
static bool isReady(const Job &job);
|
||||
static RxDataset *dataset(const Job &job, uint32_t nodeId);
|
||||
static std::pair<unsigned, unsigned> hugePages();
|
||||
static std::pair<uint32_t, uint32_t> hugePages();
|
||||
static void destroy();
|
||||
static void init();
|
||||
static void init(IRxListener *listener);
|
||||
};
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -46,7 +46,9 @@ const RandomX_ConfigurationBase *xmrig::RxAlgo::base(Algorithm::Id algorithm)
|
|||
|
||||
case Algorithm::RX_LOKI:
|
||||
return &RandomX_LokiConfig;
|
||||
break;
|
||||
|
||||
case Algorithm::RX_ARQ:
|
||||
return &RandomX_ArqmaConfig;
|
||||
|
||||
case Algorithm::DEFYX:
|
||||
return &RandomX_ScalaConfig;
|
||||
|
|
|
|||
169
src/crypto/rx/RxBasicStorage.cpp
Normal file
169
src/crypto/rx/RxBasicStorage.cpp
Normal file
|
|
@ -0,0 +1,169 @@
|
|||
/* XMRig
|
||||
* Copyright 2010 Jeff Garzik <jgarzik@pobox.com>
|
||||
* Copyright 2012-2014 pooler <pooler@litecoinpool.org>
|
||||
* Copyright 2014 Lucas Jones <https://github.com/lucasjones>
|
||||
* Copyright 2014-2016 Wolf9466 <https://github.com/OhGodAPet>
|
||||
* Copyright 2016 Jay D Dee <jayddee246@gmail.com>
|
||||
* Copyright 2017-2019 XMR-Stak <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
|
||||
* Copyright 2018 Lee Clagett <https://github.com/vtnerd>
|
||||
* Copyright 2018-2019 tevador <tevador@gmail.com>
|
||||
* Copyright 2018-2019 SChernykh <https://github.com/SChernykh>
|
||||
* Copyright 2016-2019 XMRig <https://github.com/xmrig>, <support@xmrig.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
|
||||
#include "crypto/rx/RxBasicStorage.h"
|
||||
#include "backend/common/Tags.h"
|
||||
#include "base/io/log/Log.h"
|
||||
#include "base/tools/Chrono.h"
|
||||
#include "base/tools/Object.h"
|
||||
#include "crypto/rx/RxAlgo.h"
|
||||
#include "crypto/rx/RxCache.h"
|
||||
#include "crypto/rx/RxDataset.h"
|
||||
#include "crypto/rx/RxSeed.h"
|
||||
|
||||
|
||||
namespace xmrig {
|
||||
|
||||
|
||||
constexpr size_t oneMiB = 1024 * 1024;
|
||||
|
||||
|
||||
class RxBasicStoragePrivate
|
||||
{
|
||||
public:
|
||||
XMRIG_DISABLE_COPY_MOVE(RxBasicStoragePrivate)
|
||||
|
||||
inline RxBasicStoragePrivate() = default;
|
||||
inline ~RxBasicStoragePrivate()
|
||||
{
|
||||
delete m_dataset;
|
||||
}
|
||||
|
||||
inline bool isReady(const Job &job) const { return m_ready && m_seed == job; }
|
||||
inline RxDataset *dataset() const { return m_dataset; }
|
||||
|
||||
|
||||
inline void setSeed(const RxSeed &seed)
|
||||
{
|
||||
m_ready = false;
|
||||
|
||||
if (m_seed.algorithm() != seed.algorithm()) {
|
||||
RxAlgo::apply(seed.algorithm());
|
||||
}
|
||||
|
||||
m_seed = seed;
|
||||
}
|
||||
|
||||
|
||||
inline void createDataset(bool hugePages)
|
||||
{
|
||||
const uint64_t ts = Chrono::steadyMSecs();
|
||||
|
||||
m_dataset = new RxDataset(hugePages, true);
|
||||
printAllocStatus(ts);
|
||||
}
|
||||
|
||||
|
||||
inline void initDataset(uint32_t threads)
|
||||
{
|
||||
const uint64_t ts = Chrono::steadyMSecs();
|
||||
|
||||
m_dataset->init(m_seed.data(), threads);
|
||||
|
||||
LOG_INFO("%s" GREEN_BOLD("dataset ready") BLACK_BOLD(" (%" PRIu64 " ms)"), rx_tag(), Chrono::steadyMSecs() - ts);
|
||||
|
||||
m_ready = true;
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
void printAllocStatus(uint64_t ts)
|
||||
{
|
||||
if (m_dataset->get() != nullptr) {
|
||||
const auto pages = m_dataset->hugePages();
|
||||
const double percent = pages.first == 0 ? 0.0 : static_cast<double>(pages.first) / pages.second * 100.0;
|
||||
|
||||
LOG_INFO("%s" GREEN_BOLD("allocated") CYAN_BOLD(" %zu MB") BLACK_BOLD(" (%zu+%zu)") " huge pages %s%1.0f%% %u/%u" CLEAR " %sJIT" BLACK_BOLD(" (%" PRIu64 " ms)"),
|
||||
rx_tag(),
|
||||
m_dataset->size() / oneMiB,
|
||||
RxDataset::maxSize() / oneMiB,
|
||||
RxCache::maxSize() / oneMiB,
|
||||
(pages.first == pages.second ? GREEN_BOLD_S : (pages.first == 0 ? RED_BOLD_S : YELLOW_BOLD_S)),
|
||||
percent,
|
||||
pages.first,
|
||||
pages.second,
|
||||
m_dataset->cache()->isJIT() ? GREEN_BOLD_S "+" : RED_BOLD_S "-",
|
||||
Chrono::steadyMSecs() - ts
|
||||
);
|
||||
}
|
||||
else {
|
||||
LOG_WARN(CLEAR "%s" YELLOW_BOLD_S "failed to allocate RandomX dataset, switching to slow mode" BLACK_BOLD(" (%" PRIu64 " ms)"), rx_tag(), Chrono::steadyMSecs() - ts);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
bool m_ready = false;
|
||||
RxDataset *m_dataset = nullptr;
|
||||
RxSeed m_seed;
|
||||
};
|
||||
|
||||
|
||||
} // namespace xmrig
|
||||
|
||||
|
||||
xmrig::RxBasicStorage::RxBasicStorage() :
|
||||
d_ptr(new RxBasicStoragePrivate())
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
xmrig::RxBasicStorage::~RxBasicStorage()
|
||||
{
|
||||
delete d_ptr;
|
||||
}
|
||||
|
||||
|
||||
xmrig::RxDataset *xmrig::RxBasicStorage::dataset(const Job &job, uint32_t) const
|
||||
{
|
||||
if (!d_ptr->isReady(job)) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
return d_ptr->dataset();
|
||||
}
|
||||
|
||||
|
||||
std::pair<uint32_t, uint32_t> xmrig::RxBasicStorage::hugePages() const
|
||||
{
|
||||
if (!d_ptr->dataset()) {
|
||||
return { 0u, 0u };
|
||||
}
|
||||
|
||||
return d_ptr->dataset()->hugePages();
|
||||
}
|
||||
|
||||
|
||||
void xmrig::RxBasicStorage::init(const RxSeed &seed, uint32_t threads, bool hugePages)
|
||||
{
|
||||
d_ptr->setSeed(seed);
|
||||
|
||||
if (!d_ptr->dataset()) {
|
||||
d_ptr->createDataset(hugePages);
|
||||
}
|
||||
|
||||
d_ptr->initDataset(threads);
|
||||
}
|
||||
63
src/crypto/rx/RxBasicStorage.h
Normal file
63
src/crypto/rx/RxBasicStorage.h
Normal file
|
|
@ -0,0 +1,63 @@
|
|||
/* XMRig
|
||||
* Copyright 2010 Jeff Garzik <jgarzik@pobox.com>
|
||||
* Copyright 2012-2014 pooler <pooler@litecoinpool.org>
|
||||
* Copyright 2014 Lucas Jones <https://github.com/lucasjones>
|
||||
* Copyright 2014-2016 Wolf9466 <https://github.com/OhGodAPet>
|
||||
* Copyright 2016 Jay D Dee <jayddee246@gmail.com>
|
||||
* Copyright 2017-2019 XMR-Stak <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
|
||||
* Copyright 2018 Lee Clagett <https://github.com/vtnerd>
|
||||
* Copyright 2018-2019 tevador <tevador@gmail.com>
|
||||
* Copyright 2018-2019 SChernykh <https://github.com/SChernykh>
|
||||
* Copyright 2016-2019 XMRig <https://github.com/xmrig>, <support@xmrig.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef XMRIG_RX_BASICSTORAGE_H
|
||||
#define XMRIG_RX_BASICSTORAGE_H
|
||||
|
||||
|
||||
#include "backend/common/interfaces/IRxStorage.h"
|
||||
#include "base/tools/Object.h"
|
||||
|
||||
|
||||
namespace xmrig
|
||||
{
|
||||
|
||||
|
||||
class RxBasicStoragePrivate;
|
||||
|
||||
|
||||
class RxBasicStorage : public IRxStorage
|
||||
{
|
||||
public:
|
||||
XMRIG_DISABLE_COPY_MOVE(RxBasicStorage);
|
||||
|
||||
RxBasicStorage();
|
||||
~RxBasicStorage() override;
|
||||
|
||||
protected:
|
||||
RxDataset *dataset(const Job &job, uint32_t nodeId) const override;
|
||||
std::pair<uint32_t, uint32_t> hugePages() const override;
|
||||
void init(const RxSeed &seed, uint32_t threads, bool hugePages) override;
|
||||
|
||||
private:
|
||||
RxBasicStoragePrivate *d_ptr;
|
||||
};
|
||||
|
||||
|
||||
} /* namespace xmrig */
|
||||
|
||||
|
||||
#endif /* XMRIG_RX_BASICSTORAGE_H */
|
||||
|
|
@ -25,8 +25,9 @@
|
|||
*/
|
||||
|
||||
|
||||
#include "crypto/randomx/randomx.h"
|
||||
#include "crypto/rx/RxCache.h"
|
||||
#include "crypto/common/VirtualMemory.h"
|
||||
#include "crypto/randomx/randomx.h"
|
||||
|
||||
|
||||
static_assert(RANDOMX_FLAG_JIT == 8, "RANDOMX_FLAG_JIT flag mismatch");
|
||||
|
|
@ -72,3 +73,17 @@ bool xmrig::RxCache::init(const Buffer &seed)
|
|||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
std::pair<uint32_t, uint32_t> xmrig::RxCache::hugePages() const
|
||||
{
|
||||
constexpr size_t twoMiB = 2u * 1024u * 1024u;
|
||||
constexpr size_t total = VirtualMemory::align(maxSize(), twoMiB) / twoMiB;
|
||||
|
||||
uint32_t count = 0;
|
||||
if (isHugePages()) {
|
||||
count += total;
|
||||
}
|
||||
|
||||
return { count, total };
|
||||
}
|
||||
|
|
|
|||
|
|
@ -55,8 +55,10 @@ public:
|
|||
inline bool isJIT() const { return m_flags & 8; }
|
||||
inline const Buffer &seed() const { return m_seed; }
|
||||
inline randomx_cache *get() const { return m_cache; }
|
||||
inline size_t size() const { return maxSize(); }
|
||||
|
||||
bool init(const Buffer &seed);
|
||||
std::pair<uint32_t, uint32_t> hugePages() const;
|
||||
|
||||
static inline constexpr size_t maxSize() { return RANDOMX_CACHE_MAX_SIZE; }
|
||||
|
||||
|
|
|
|||
|
|
@ -23,41 +23,11 @@
|
|||
*/
|
||||
|
||||
|
||||
#include "base/io/json/Json.h"
|
||||
#include "crypto/rx/RxConfig.h"
|
||||
#include "rapidjson/document.h"
|
||||
#include "backend/cpu/Cpu.h"
|
||||
|
||||
|
||||
namespace xmrig {
|
||||
|
||||
static const char *kInit = "init";
|
||||
static const char *kNUMA = "numa";
|
||||
|
||||
}
|
||||
|
||||
|
||||
rapidjson::Value xmrig::RxConfig::toJSON(rapidjson::Document &doc) const
|
||||
uint32_t xmrig::RxConfig::threads() const
|
||||
{
|
||||
using namespace rapidjson;
|
||||
auto &allocator = doc.GetAllocator();
|
||||
|
||||
Value obj(kObjectType);
|
||||
|
||||
obj.AddMember(StringRef(kInit), m_threads, allocator);
|
||||
obj.AddMember(StringRef(kNUMA), m_numa, allocator);
|
||||
|
||||
return obj;
|
||||
}
|
||||
|
||||
|
||||
bool xmrig::RxConfig::read(const rapidjson::Value &value)
|
||||
{
|
||||
if (value.IsObject()) {
|
||||
m_numa = Json::getBool(value, kNUMA, m_numa);
|
||||
m_threads = Json::getInt(value, kInit, m_threads);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
return m_threads < 1 ? static_cast<uint32_t>(Cpu::info()->threads()) : static_cast<uint32_t>(m_threads);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -29,6 +29,9 @@
|
|||
#include "rapidjson/fwd.h"
|
||||
|
||||
|
||||
#include <vector>
|
||||
|
||||
|
||||
namespace xmrig {
|
||||
|
||||
|
||||
|
|
@ -38,12 +41,22 @@ public:
|
|||
bool read(const rapidjson::Value &value);
|
||||
rapidjson::Value toJSON(rapidjson::Document &doc) const;
|
||||
|
||||
inline bool isNUMA() const { return m_numa; }
|
||||
inline int threads() const { return m_threads; }
|
||||
# ifdef XMRIG_FEATURE_HWLOC
|
||||
std::vector<uint32_t> nodeset() const;
|
||||
# else
|
||||
inline std::vector<uint32_t> nodeset() const { return std::vector<uint32_t>(); }
|
||||
# endif
|
||||
|
||||
uint32_t threads() const;
|
||||
|
||||
private:
|
||||
bool m_numa = true;
|
||||
int m_threads = -1;
|
||||
|
||||
# ifdef XMRIG_FEATURE_HWLOC
|
||||
std::vector<uint32_t> m_nodeset;
|
||||
# endif
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
|
|
|||
59
src/crypto/rx/RxConfig_basic.cpp
Normal file
59
src/crypto/rx/RxConfig_basic.cpp
Normal file
|
|
@ -0,0 +1,59 @@
|
|||
/* XMRig
|
||||
* Copyright 2010 Jeff Garzik <jgarzik@pobox.com>
|
||||
* Copyright 2012-2014 pooler <pooler@litecoinpool.org>
|
||||
* Copyright 2014 Lucas Jones <https://github.com/lucasjones>
|
||||
* Copyright 2014-2016 Wolf9466 <https://github.com/OhGodAPet>
|
||||
* Copyright 2016 Jay D Dee <jayddee246@gmail.com>
|
||||
* Copyright 2017-2018 XMR-Stak <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
|
||||
* Copyright 2018-2019 SChernykh <https://github.com/SChernykh>
|
||||
* Copyright 2016-2019 XMRig <https://github.com/xmrig>, <support@xmrig.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
|
||||
#include "crypto/rx/RxConfig.h"
|
||||
#include "base/io/json/Json.h"
|
||||
#include "rapidjson/document.h"
|
||||
|
||||
|
||||
namespace xmrig {
|
||||
|
||||
static const char *kInit = "init";
|
||||
|
||||
}
|
||||
|
||||
|
||||
rapidjson::Value xmrig::RxConfig::toJSON(rapidjson::Document &doc) const
|
||||
{
|
||||
using namespace rapidjson;
|
||||
auto &allocator = doc.GetAllocator();
|
||||
|
||||
Value obj(kObjectType);
|
||||
obj.AddMember(StringRef(kInit), m_threads, allocator);
|
||||
|
||||
return obj;
|
||||
}
|
||||
|
||||
|
||||
bool xmrig::RxConfig::read(const rapidjson::Value &value)
|
||||
{
|
||||
if (value.IsObject()) {
|
||||
m_threads = Json::getInt(value, kInit, m_threads);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
100
src/crypto/rx/RxConfig_hwloc.cpp
Normal file
100
src/crypto/rx/RxConfig_hwloc.cpp
Normal file
|
|
@ -0,0 +1,100 @@
|
|||
/* XMRig
|
||||
* Copyright 2010 Jeff Garzik <jgarzik@pobox.com>
|
||||
* Copyright 2012-2014 pooler <pooler@litecoinpool.org>
|
||||
* Copyright 2014 Lucas Jones <https://github.com/lucasjones>
|
||||
* Copyright 2014-2016 Wolf9466 <https://github.com/OhGodAPet>
|
||||
* Copyright 2016 Jay D Dee <jayddee246@gmail.com>
|
||||
* Copyright 2017-2018 XMR-Stak <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
|
||||
* Copyright 2018-2019 SChernykh <https://github.com/SChernykh>
|
||||
* Copyright 2016-2019 XMRig <https://github.com/xmrig>, <support@xmrig.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
|
||||
#include "backend/cpu/Cpu.h"
|
||||
#include "backend/cpu/platform/HwlocCpuInfo.h"
|
||||
#include "base/io/json/Json.h"
|
||||
#include "crypto/rx/RxConfig.h"
|
||||
#include "rapidjson/document.h"
|
||||
|
||||
|
||||
namespace xmrig {
|
||||
|
||||
static const char *kInit = "init";
|
||||
static const char *kNUMA = "numa";
|
||||
|
||||
}
|
||||
|
||||
|
||||
rapidjson::Value xmrig::RxConfig::toJSON(rapidjson::Document &doc) const
|
||||
{
|
||||
using namespace rapidjson;
|
||||
auto &allocator = doc.GetAllocator();
|
||||
|
||||
Value obj(kObjectType);
|
||||
|
||||
obj.AddMember(StringRef(kInit), m_threads, allocator);
|
||||
|
||||
if (!m_nodeset.empty()) {
|
||||
Value numa(kArrayType);
|
||||
|
||||
for (uint32_t i : m_nodeset) {
|
||||
numa.PushBack(i, allocator);
|
||||
}
|
||||
|
||||
obj.AddMember(StringRef(kNUMA), numa, allocator);
|
||||
}
|
||||
else {
|
||||
obj.AddMember(StringRef(kNUMA), m_numa, allocator);
|
||||
}
|
||||
|
||||
return obj;
|
||||
}
|
||||
|
||||
|
||||
bool xmrig::RxConfig::read(const rapidjson::Value &value)
|
||||
{
|
||||
if (value.IsObject()) {
|
||||
m_threads = Json::getInt(value, kInit, m_threads);
|
||||
|
||||
const auto &numa = Json::getValue(value, kNUMA);
|
||||
if (numa.IsArray()) {
|
||||
m_nodeset.reserve(numa.Size());
|
||||
|
||||
for (const auto &node : numa.GetArray()) {
|
||||
if (node.IsUint()) {
|
||||
m_nodeset.emplace_back(node.GetUint());
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (numa.IsBool()) {
|
||||
m_numa = numa.GetBool();
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
std::vector<uint32_t> xmrig::RxConfig::nodeset() const
|
||||
{
|
||||
if (!m_nodeset.empty()) {
|
||||
return m_nodeset;
|
||||
}
|
||||
|
||||
return (m_numa && Cpu::info()->nodes() > 1) ? static_cast<HwlocCpuInfo *>(Cpu::info())->nodeset() : std::vector<uint32_t>();
|
||||
}
|
||||
|
|
@ -25,32 +25,32 @@
|
|||
*/
|
||||
|
||||
|
||||
#include <thread>
|
||||
|
||||
|
||||
#include "crypto/rx/RxDataset.h"
|
||||
#include "crypto/common/VirtualMemory.h"
|
||||
#include "crypto/randomx/randomx.h"
|
||||
#include "crypto/rx/RxAlgo.h"
|
||||
#include "crypto/rx/RxCache.h"
|
||||
#include "crypto/rx/RxDataset.h"
|
||||
|
||||
|
||||
#include <thread>
|
||||
|
||||
|
||||
static_assert(RANDOMX_FLAG_LARGE_PAGES == 1, "RANDOMX_FLAG_LARGE_PAGES flag mismatch");
|
||||
|
||||
|
||||
xmrig::RxDataset::RxDataset(bool hugePages)
|
||||
xmrig::RxDataset::RxDataset(bool hugePages, bool cache)
|
||||
{
|
||||
if (hugePages) {
|
||||
m_flags = RANDOMX_FLAG_LARGE_PAGES;
|
||||
m_dataset = randomx_alloc_dataset(static_cast<randomx_flags>(m_flags));
|
||||
}
|
||||
allocate(hugePages);
|
||||
|
||||
if (!m_dataset) {
|
||||
m_flags = RANDOMX_FLAG_DEFAULT;
|
||||
m_dataset = randomx_alloc_dataset(static_cast<randomx_flags>(m_flags));
|
||||
if (cache) {
|
||||
m_cache = new RxCache(hugePages);
|
||||
}
|
||||
}
|
||||
|
||||
m_cache = new RxCache(hugePages);
|
||||
|
||||
xmrig::RxDataset::RxDataset(RxCache *cache) :
|
||||
m_cache(cache)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -66,7 +66,11 @@ xmrig::RxDataset::~RxDataset()
|
|||
|
||||
bool xmrig::RxDataset::init(const Buffer &seed, uint32_t numThreads)
|
||||
{
|
||||
cache()->init(seed);
|
||||
if (!m_cache) {
|
||||
return false;
|
||||
}
|
||||
|
||||
m_cache->init(seed);
|
||||
|
||||
if (!get()) {
|
||||
return true;
|
||||
|
|
@ -96,18 +100,39 @@ bool xmrig::RxDataset::init(const Buffer &seed, uint32_t numThreads)
|
|||
}
|
||||
|
||||
|
||||
std::pair<size_t, size_t> xmrig::RxDataset::hugePages() const
|
||||
size_t xmrig::RxDataset::size(bool cache) const
|
||||
{
|
||||
constexpr size_t twoMiB = 2u * 1024u * 1024u;
|
||||
constexpr const size_t total = (VirtualMemory::align(maxSize(), twoMiB) + VirtualMemory::align(RxCache::maxSize(), twoMiB)) / twoMiB;
|
||||
size_t size = 0;
|
||||
|
||||
size_t count = 0;
|
||||
if (isHugePages()) {
|
||||
count += VirtualMemory::align(maxSize(), twoMiB) / twoMiB;
|
||||
if (m_dataset) {
|
||||
size += maxSize();
|
||||
}
|
||||
|
||||
if (m_cache->isHugePages()) {
|
||||
count += VirtualMemory::align(RxCache::maxSize(), twoMiB) / twoMiB;
|
||||
if (cache && m_cache) {
|
||||
size += RxCache::maxSize();
|
||||
}
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
|
||||
std::pair<uint32_t, uint32_t> xmrig::RxDataset::hugePages(bool cache) const
|
||||
{
|
||||
constexpr size_t twoMiB = 2u * 1024u * 1024u;
|
||||
constexpr size_t cacheSize = VirtualMemory::align(RxCache::maxSize(), twoMiB) / twoMiB;
|
||||
size_t total = VirtualMemory::align(maxSize(), twoMiB) / twoMiB;
|
||||
|
||||
uint32_t count = 0;
|
||||
if (isHugePages()) {
|
||||
count += total;
|
||||
}
|
||||
|
||||
if (cache && m_cache) {
|
||||
total += cacheSize;
|
||||
|
||||
if (m_cache->isHugePages()) {
|
||||
count += cacheSize;
|
||||
}
|
||||
}
|
||||
|
||||
return { count, total };
|
||||
|
|
@ -118,3 +143,27 @@ void *xmrig::RxDataset::raw() const
|
|||
{
|
||||
return m_dataset ? randomx_get_dataset_memory(m_dataset) : nullptr;
|
||||
}
|
||||
|
||||
|
||||
void xmrig::RxDataset::setRaw(const void *raw)
|
||||
{
|
||||
if (!m_dataset) {
|
||||
return;
|
||||
}
|
||||
|
||||
memcpy(randomx_get_dataset_memory(m_dataset), raw, maxSize());
|
||||
}
|
||||
|
||||
|
||||
void xmrig::RxDataset::allocate(bool hugePages)
|
||||
{
|
||||
if (hugePages) {
|
||||
m_flags = RANDOMX_FLAG_LARGE_PAGES;
|
||||
m_dataset = randomx_alloc_dataset(static_cast<randomx_flags>(m_flags));
|
||||
}
|
||||
|
||||
if (!m_dataset) {
|
||||
m_flags = RANDOMX_FLAG_DEFAULT;
|
||||
m_dataset = randomx_alloc_dataset(static_cast<randomx_flags>(m_flags));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -49,22 +49,26 @@ class RxDataset
|
|||
public:
|
||||
XMRIG_DISABLE_COPY_MOVE_DEFAULT(RxDataset)
|
||||
|
||||
RxDataset(bool hugePages = true);
|
||||
RxDataset(bool hugePages, bool cache);
|
||||
RxDataset(RxCache *cache);
|
||||
~RxDataset();
|
||||
|
||||
inline bool isHugePages() const { return m_flags & 1; }
|
||||
inline randomx_dataset *get() const { return m_dataset; }
|
||||
inline RxCache *cache() const { return m_cache; }
|
||||
inline size_t size() const { return maxSize(); }
|
||||
inline bool isHugePages() const { return m_flags & 1; }
|
||||
inline randomx_dataset *get() const { return m_dataset; }
|
||||
inline RxCache *cache() const { return m_cache; }
|
||||
inline void setCache(RxCache *cache) { m_cache = cache; }
|
||||
|
||||
bool init(const Buffer &seed, uint32_t numThreads);
|
||||
std::pair<size_t, size_t> hugePages() const;
|
||||
size_t size(bool cache = true) const;
|
||||
std::pair<uint32_t, uint32_t> hugePages(bool cache = true) const;
|
||||
void *raw() const;
|
||||
void setRaw(const void *raw);
|
||||
|
||||
static inline constexpr size_t maxSize() { return RANDOMX_DATASET_MAX_SIZE; }
|
||||
|
||||
private:
|
||||
Algorithm m_algorithm;
|
||||
void allocate(bool hugePages);
|
||||
|
||||
int m_flags = 0;
|
||||
randomx_dataset *m_dataset = nullptr;
|
||||
RxCache *m_cache = nullptr;
|
||||
|
|
|
|||
358
src/crypto/rx/RxNUMAStorage.cpp
Normal file
358
src/crypto/rx/RxNUMAStorage.cpp
Normal file
|
|
@ -0,0 +1,358 @@
|
|||
/* XMRig
|
||||
* Copyright 2010 Jeff Garzik <jgarzik@pobox.com>
|
||||
* Copyright 2012-2014 pooler <pooler@litecoinpool.org>
|
||||
* Copyright 2014 Lucas Jones <https://github.com/lucasjones>
|
||||
* Copyright 2014-2016 Wolf9466 <https://github.com/OhGodAPet>
|
||||
* Copyright 2016 Jay D Dee <jayddee246@gmail.com>
|
||||
* Copyright 2017-2019 XMR-Stak <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
|
||||
* Copyright 2018 Lee Clagett <https://github.com/vtnerd>
|
||||
* Copyright 2018-2019 tevador <tevador@gmail.com>
|
||||
* Copyright 2018-2019 SChernykh <https://github.com/SChernykh>
|
||||
* Copyright 2016-2019 XMRig <https://github.com/xmrig>, <support@xmrig.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
|
||||
#include "crypto/rx/RxNUMAStorage.h"
|
||||
#include "backend/common/Tags.h"
|
||||
#include "backend/cpu/Cpu.h"
|
||||
#include "backend/cpu/platform/HwlocCpuInfo.h"
|
||||
#include "base/io/log/Log.h"
|
||||
#include "base/kernel/Platform.h"
|
||||
#include "base/tools/Chrono.h"
|
||||
#include "base/tools/Object.h"
|
||||
#include "crypto/rx/RxAlgo.h"
|
||||
#include "crypto/rx/RxCache.h"
|
||||
#include "crypto/rx/RxDataset.h"
|
||||
#include "crypto/rx/RxSeed.h"
|
||||
|
||||
|
||||
#include <map>
|
||||
#include <mutex>
|
||||
#include <hwloc.h>
|
||||
#include <thread>
|
||||
|
||||
|
||||
namespace xmrig {
|
||||
|
||||
|
||||
constexpr size_t oneMiB = 1024 * 1024;
|
||||
static std::mutex mutex;
|
||||
|
||||
|
||||
static bool bindToNUMANode(uint32_t nodeId)
|
||||
{
|
||||
auto cpu = static_cast<HwlocCpuInfo *>(Cpu::info());
|
||||
hwloc_obj_t node = hwloc_get_numanode_obj_by_os_index(cpu->topology(), nodeId);
|
||||
if (!node) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (cpu->membind(node->nodeset)) {
|
||||
Platform::setThreadAffinity(static_cast<uint64_t>(hwloc_bitmap_first(node->cpuset)));
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
static inline void printSkipped(uint32_t nodeId, const char *reason)
|
||||
{
|
||||
LOG_WARN("%s" CYAN_BOLD("#%u ") RED_BOLD("skipped") YELLOW(" (%s)"), rx_tag(), nodeId, reason);
|
||||
}
|
||||
|
||||
|
||||
static inline void printDatasetReady(uint32_t nodeId, uint64_t ts)
|
||||
{
|
||||
LOG_INFO("%s" CYAN_BOLD("#%u ") GREEN_BOLD("dataset ready") BLACK_BOLD(" (%" PRIu64 " ms)"), rx_tag(), nodeId, Chrono::steadyMSecs() - ts);
|
||||
}
|
||||
|
||||
|
||||
class RxNUMAStoragePrivate
|
||||
{
|
||||
public:
|
||||
XMRIG_DISABLE_COPY_MOVE_DEFAULT(RxNUMAStoragePrivate)
|
||||
|
||||
inline RxNUMAStoragePrivate(const std::vector<uint32_t> &nodeset) :
|
||||
m_nodeset(nodeset)
|
||||
{
|
||||
m_threads.reserve(nodeset.size());
|
||||
}
|
||||
|
||||
|
||||
inline ~RxNUMAStoragePrivate()
|
||||
{
|
||||
join();
|
||||
|
||||
for (auto const &item : m_datasets) {
|
||||
delete item.second;
|
||||
}
|
||||
}
|
||||
|
||||
inline bool isAllocated() const { return m_allocated; }
|
||||
inline bool isReady(const Job &job) const { return m_ready && m_seed == job; }
|
||||
inline RxDataset *dataset(uint32_t nodeId) const { return m_datasets.count(nodeId) ? m_datasets.at(nodeId) : m_datasets.at(m_nodeset.front()); }
|
||||
|
||||
|
||||
inline void setSeed(const RxSeed &seed)
|
||||
{
|
||||
m_ready = false;
|
||||
|
||||
if (m_seed.algorithm() != seed.algorithm()) {
|
||||
RxAlgo::apply(seed.algorithm());
|
||||
}
|
||||
|
||||
m_seed = seed;
|
||||
}
|
||||
|
||||
|
||||
inline void createDatasets(bool hugePages)
|
||||
{
|
||||
const uint64_t ts = Chrono::steadyMSecs();
|
||||
|
||||
for (uint32_t node : m_nodeset) {
|
||||
m_threads.emplace_back(allocate, this, node, hugePages);
|
||||
}
|
||||
|
||||
join();
|
||||
|
||||
std::thread thread(allocateCache, this, m_nodeset.front(), hugePages);
|
||||
thread.join();
|
||||
|
||||
if (m_datasets.empty()) {
|
||||
m_datasets.insert({ m_nodeset.front(), new RxDataset(m_cache) });
|
||||
|
||||
LOG_WARN(CLEAR "%s" YELLOW_BOLD_S "failed to allocate RandomX datasets, switching to slow mode" BLACK_BOLD(" (%" PRIu64 " ms)"), rx_tag(), Chrono::steadyMSecs() - ts);
|
||||
}
|
||||
else {
|
||||
dataset(m_nodeset.front())->setCache(m_cache);
|
||||
|
||||
printAllocStatus(ts);
|
||||
}
|
||||
|
||||
m_allocated = true;
|
||||
}
|
||||
|
||||
|
||||
inline void initDatasets(uint32_t threads)
|
||||
{
|
||||
uint64_t ts = Chrono::steadyMSecs();
|
||||
auto id = m_nodeset.front();
|
||||
auto primary = dataset(id);
|
||||
|
||||
primary->init(m_seed.data(), threads);
|
||||
|
||||
printDatasetReady(id, ts);
|
||||
|
||||
if (m_datasets.size() > 1) {
|
||||
for (auto const &item : m_datasets) {
|
||||
if (item.first == id) {
|
||||
continue;
|
||||
}
|
||||
|
||||
m_threads.emplace_back(copyDataset, item.second, item.first, primary->raw());
|
||||
}
|
||||
|
||||
join();
|
||||
}
|
||||
|
||||
m_ready = true;
|
||||
}
|
||||
|
||||
|
||||
inline std::pair<uint32_t, uint32_t> hugePages() const
|
||||
{
|
||||
auto pages = m_cache->hugePages();
|
||||
for (auto const &item : m_datasets) {
|
||||
const auto p = item.second->hugePages(false);
|
||||
pages.first += p.first;
|
||||
pages.second += p.second;
|
||||
}
|
||||
|
||||
return pages;
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
static void allocate(RxNUMAStoragePrivate *d_ptr, uint32_t nodeId, bool hugePages)
|
||||
{
|
||||
const uint64_t ts = Chrono::steadyMSecs();
|
||||
|
||||
if (!bindToNUMANode(nodeId)) {
|
||||
printSkipped(nodeId, "can't bind memory");
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
auto dataset = new RxDataset(hugePages, false);
|
||||
if (!dataset->get()) {
|
||||
printSkipped(nodeId, "failed to allocate dataset");
|
||||
|
||||
delete dataset;
|
||||
return;
|
||||
}
|
||||
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
d_ptr->m_datasets.insert({ nodeId, dataset });
|
||||
d_ptr->printAllocStatus(dataset, nodeId, ts);
|
||||
}
|
||||
|
||||
|
||||
static void allocateCache(RxNUMAStoragePrivate *d_ptr, uint32_t nodeId, bool hugePages)
|
||||
{
|
||||
const uint64_t ts = Chrono::steadyMSecs();
|
||||
|
||||
bindToNUMANode(nodeId);
|
||||
|
||||
auto cache = new RxCache(hugePages);
|
||||
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
d_ptr->m_cache = cache;
|
||||
d_ptr->printAllocStatus(cache, nodeId, ts);
|
||||
}
|
||||
|
||||
|
||||
static void copyDataset(RxDataset *dst, uint32_t nodeId, const void *raw)
|
||||
{
|
||||
const uint64_t ts = Chrono::steadyMSecs();
|
||||
|
||||
dst->setRaw(raw);
|
||||
|
||||
printDatasetReady(nodeId, ts);
|
||||
}
|
||||
|
||||
|
||||
void printAllocStatus(RxDataset *dataset, uint32_t nodeId, uint64_t ts)
|
||||
{
|
||||
const auto pages = dataset->hugePages();
|
||||
const double percent = pages.first == 0 ? 0.0 : static_cast<double>(pages.first) / pages.second * 100.0;
|
||||
|
||||
LOG_INFO("%s" CYAN_BOLD("#%u ") GREEN_BOLD("allocated") CYAN_BOLD(" %zu MB") " huge pages %s%3.0f%%" CLEAR BLACK_BOLD(" (%" PRIu64 " ms)"),
|
||||
rx_tag(),
|
||||
nodeId,
|
||||
dataset->size() / oneMiB,
|
||||
(pages.first == pages.second ? GREEN_BOLD_S : RED_BOLD_S),
|
||||
percent,
|
||||
Chrono::steadyMSecs() - ts
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
void printAllocStatus(RxCache *cache, uint32_t nodeId, uint64_t ts)
|
||||
{
|
||||
const auto pages = cache->hugePages();
|
||||
const double percent = pages.first == 0 ? 0.0 : static_cast<double>(pages.first) / pages.second * 100.0;
|
||||
|
||||
LOG_INFO("%s" CYAN_BOLD("#%u ") GREEN_BOLD("allocated") CYAN_BOLD(" %4zu MB") " huge pages %s%3.0f%%" CLEAR " %sJIT" BLACK_BOLD(" (%" PRIu64 " ms)"),
|
||||
rx_tag(),
|
||||
nodeId,
|
||||
cache->size() / oneMiB,
|
||||
(pages.first == pages.second ? GREEN_BOLD_S : RED_BOLD_S),
|
||||
percent,
|
||||
cache->isJIT() ? GREEN_BOLD_S "+" : RED_BOLD_S "-",
|
||||
Chrono::steadyMSecs() - ts
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
void printAllocStatus(uint64_t ts)
|
||||
{
|
||||
size_t memory = m_cache->size();
|
||||
auto pages = hugePages();
|
||||
const double percent = pages.first == 0 ? 0.0 : static_cast<double>(pages.first) / pages.second * 100.0;
|
||||
|
||||
for (auto const &item : m_datasets) {
|
||||
memory += item.second->size(false);
|
||||
}
|
||||
|
||||
LOG_INFO("%s" CYAN_BOLD("-- ") GREEN_BOLD("allocated") CYAN_BOLD(" %4zu MB") " huge pages %s%3.0f%% %u/%u" CLEAR BLACK_BOLD(" (%" PRIu64 " ms)"),
|
||||
rx_tag(),
|
||||
memory / oneMiB,
|
||||
(pages.first == pages.second ? GREEN_BOLD_S : (pages.first == 0 ? RED_BOLD_S : YELLOW_BOLD_S)),
|
||||
percent,
|
||||
pages.first,
|
||||
pages.second,
|
||||
Chrono::steadyMSecs() - ts
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
inline void join()
|
||||
{
|
||||
for (auto &thread : m_threads) {
|
||||
thread.join();
|
||||
}
|
||||
|
||||
m_threads.clear();
|
||||
}
|
||||
|
||||
|
||||
bool m_allocated = false;
|
||||
bool m_ready = false;
|
||||
RxCache *m_cache = nullptr;
|
||||
RxSeed m_seed;
|
||||
std::map<uint32_t, RxDataset *> m_datasets;
|
||||
std::vector<std::thread> m_threads;
|
||||
std::vector<uint32_t> m_nodeset;
|
||||
};
|
||||
|
||||
|
||||
} // namespace xmrig
|
||||
|
||||
|
||||
xmrig::RxNUMAStorage::RxNUMAStorage(const std::vector<uint32_t> &nodeset) :
|
||||
d_ptr(new RxNUMAStoragePrivate(nodeset))
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
xmrig::RxNUMAStorage::~RxNUMAStorage()
|
||||
{
|
||||
delete d_ptr;
|
||||
}
|
||||
|
||||
|
||||
xmrig::RxDataset *xmrig::RxNUMAStorage::dataset(const Job &job, uint32_t nodeId) const
|
||||
{
|
||||
if (!d_ptr->isReady(job)) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
return d_ptr->dataset(nodeId);
|
||||
}
|
||||
|
||||
|
||||
std::pair<uint32_t, uint32_t> xmrig::RxNUMAStorage::hugePages() const
|
||||
{
|
||||
if (!d_ptr->isAllocated()) {
|
||||
return { 0u, 0u };
|
||||
}
|
||||
|
||||
return d_ptr->hugePages();
|
||||
}
|
||||
|
||||
|
||||
void xmrig::RxNUMAStorage::init(const RxSeed &seed, uint32_t threads, bool hugePages)
|
||||
{
|
||||
d_ptr->setSeed(seed);
|
||||
|
||||
if (!d_ptr->isAllocated()) {
|
||||
d_ptr->createDatasets(hugePages);
|
||||
}
|
||||
|
||||
d_ptr->initDatasets(threads);
|
||||
}
|
||||
66
src/crypto/rx/RxNUMAStorage.h
Normal file
66
src/crypto/rx/RxNUMAStorage.h
Normal file
|
|
@ -0,0 +1,66 @@
|
|||
/* XMRig
|
||||
* Copyright 2010 Jeff Garzik <jgarzik@pobox.com>
|
||||
* Copyright 2012-2014 pooler <pooler@litecoinpool.org>
|
||||
* Copyright 2014 Lucas Jones <https://github.com/lucasjones>
|
||||
* Copyright 2014-2016 Wolf9466 <https://github.com/OhGodAPet>
|
||||
* Copyright 2016 Jay D Dee <jayddee246@gmail.com>
|
||||
* Copyright 2017-2019 XMR-Stak <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
|
||||
* Copyright 2018 Lee Clagett <https://github.com/vtnerd>
|
||||
* Copyright 2018-2019 tevador <tevador@gmail.com>
|
||||
* Copyright 2018-2019 SChernykh <https://github.com/SChernykh>
|
||||
* Copyright 2016-2019 XMRig <https://github.com/xmrig>, <support@xmrig.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef XMRIG_RX_NUMASTORAGE_H
|
||||
#define XMRIG_RX_NUMASTORAGE_H
|
||||
|
||||
|
||||
#include "backend/common/interfaces/IRxStorage.h"
|
||||
#include "base/tools/Object.h"
|
||||
|
||||
|
||||
#include <vector>
|
||||
|
||||
|
||||
namespace xmrig
|
||||
{
|
||||
|
||||
|
||||
class RxNUMAStoragePrivate;
|
||||
|
||||
|
||||
class RxNUMAStorage : public IRxStorage
|
||||
{
|
||||
public:
|
||||
XMRIG_DISABLE_COPY_MOVE(RxNUMAStorage);
|
||||
|
||||
RxNUMAStorage(const std::vector<uint32_t> &nodeset);
|
||||
~RxNUMAStorage() override;
|
||||
|
||||
protected:
|
||||
RxDataset *dataset(const Job &job, uint32_t nodeId) const override;
|
||||
std::pair<uint32_t, uint32_t> hugePages() const override;
|
||||
void init(const RxSeed &seed, uint32_t threads, bool hugePages) override;
|
||||
|
||||
private:
|
||||
RxNUMAStoragePrivate *d_ptr;
|
||||
};
|
||||
|
||||
|
||||
} /* namespace xmrig */
|
||||
|
||||
|
||||
#endif /* XMRIG_RX_NUMASTORAGE_H */
|
||||
182
src/crypto/rx/RxQueue.cpp
Normal file
182
src/crypto/rx/RxQueue.cpp
Normal file
|
|
@ -0,0 +1,182 @@
|
|||
/* XMRig
|
||||
* Copyright 2010 Jeff Garzik <jgarzik@pobox.com>
|
||||
* Copyright 2012-2014 pooler <pooler@litecoinpool.org>
|
||||
* Copyright 2014 Lucas Jones <https://github.com/lucasjones>
|
||||
* Copyright 2014-2016 Wolf9466 <https://github.com/OhGodAPet>
|
||||
* Copyright 2016 Jay D Dee <jayddee246@gmail.com>
|
||||
* Copyright 2017-2019 XMR-Stak <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
|
||||
* Copyright 2018 Lee Clagett <https://github.com/vtnerd>
|
||||
* Copyright 2018-2019 tevador <tevador@gmail.com>
|
||||
* Copyright 2018-2019 SChernykh <https://github.com/SChernykh>
|
||||
* Copyright 2016-2019 XMRig <https://github.com/xmrig>, <support@xmrig.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
|
||||
#include "crypto/rx/RxQueue.h"
|
||||
#include "backend/common/Tags.h"
|
||||
#include "base/io/log/Log.h"
|
||||
#include "crypto/rx/RxBasicStorage.h"
|
||||
#include "base/tools/Handle.h"
|
||||
#include "backend/common/interfaces/IRxListener.h"
|
||||
|
||||
|
||||
#ifdef XMRIG_FEATURE_HWLOC
|
||||
# include "crypto/rx/RxNUMAStorage.h"
|
||||
#endif
|
||||
|
||||
|
||||
xmrig::RxQueue::RxQueue(IRxListener *listener) :
|
||||
m_listener(listener)
|
||||
{
|
||||
m_async = new uv_async_t;
|
||||
m_async->data = this;
|
||||
|
||||
uv_async_init(uv_default_loop(), m_async, [](uv_async_t *handle) { static_cast<RxQueue *>(handle->data)->onReady(); });
|
||||
|
||||
m_thread = std::move(std::thread(&RxQueue::backgroundInit, this));
|
||||
}
|
||||
|
||||
|
||||
xmrig::RxQueue::~RxQueue()
|
||||
{
|
||||
std::unique_lock<std::mutex> lock(m_mutex);
|
||||
m_state = STATE_SHUTDOWN;
|
||||
lock.unlock();
|
||||
|
||||
m_cv.notify_one();
|
||||
|
||||
m_thread.join();
|
||||
|
||||
delete m_storage;
|
||||
|
||||
Handle::close(m_async);
|
||||
}
|
||||
|
||||
|
||||
bool xmrig::RxQueue::isReady(const Job &job)
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(m_mutex);
|
||||
|
||||
return isReadyUnsafe(job);
|
||||
}
|
||||
|
||||
|
||||
xmrig::RxDataset *xmrig::RxQueue::dataset(const Job &job, uint32_t nodeId)
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(m_mutex);
|
||||
|
||||
if (isReadyUnsafe(job)) {
|
||||
return m_storage->dataset(job, nodeId);
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
|
||||
std::pair<uint32_t, uint32_t> xmrig::RxQueue::hugePages()
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(m_mutex);
|
||||
|
||||
return m_storage && m_state == STATE_IDLE ? m_storage->hugePages() : std::pair<uint32_t, uint32_t>(0u, 0u);
|
||||
}
|
||||
|
||||
|
||||
void xmrig::RxQueue::enqueue(const RxSeed &seed, const std::vector<uint32_t> &nodeset, uint32_t threads, bool hugePages)
|
||||
{
|
||||
std::unique_lock<std::mutex> lock(m_mutex);
|
||||
|
||||
if (!m_storage) {
|
||||
# ifdef XMRIG_FEATURE_HWLOC
|
||||
if (!nodeset.empty()) {
|
||||
m_storage = new RxNUMAStorage(nodeset);
|
||||
}
|
||||
else
|
||||
# endif
|
||||
{
|
||||
m_storage = new RxBasicStorage();
|
||||
}
|
||||
}
|
||||
|
||||
if (m_state == STATE_PENDING && m_seed == seed) {
|
||||
return;
|
||||
}
|
||||
|
||||
m_queue.emplace_back(seed, nodeset, threads, hugePages);
|
||||
m_seed = seed;
|
||||
m_state = STATE_PENDING;
|
||||
|
||||
lock.unlock();
|
||||
|
||||
m_cv.notify_one();
|
||||
}
|
||||
|
||||
|
||||
bool xmrig::RxQueue::isReadyUnsafe(const Job &job) const
|
||||
{
|
||||
return m_storage != nullptr && m_state == STATE_IDLE && m_seed == job;
|
||||
}
|
||||
|
||||
|
||||
void xmrig::RxQueue::backgroundInit()
|
||||
{
|
||||
while (m_state != STATE_SHUTDOWN) {
|
||||
std::unique_lock<std::mutex> lock(m_mutex);
|
||||
|
||||
if (m_state == STATE_IDLE) {
|
||||
m_cv.wait(lock, [this]{ return m_state != STATE_IDLE; });
|
||||
}
|
||||
|
||||
if (m_state != STATE_PENDING) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const auto item = m_queue.back();
|
||||
m_queue.clear();
|
||||
|
||||
lock.unlock();
|
||||
|
||||
LOG_INFO("%s" MAGENTA_BOLD("init dataset%s") " algo " WHITE_BOLD("%s (") CYAN_BOLD("%u") WHITE_BOLD(" threads)") BLACK_BOLD(" seed %s..."),
|
||||
rx_tag(),
|
||||
item.nodeset.size() > 1 ? "s" : "",
|
||||
item.seed.algorithm().shortName(),
|
||||
item.threads,
|
||||
Buffer::toHex(item.seed.data().data(), 8).data()
|
||||
);
|
||||
|
||||
m_storage->init(item.seed, item.threads, item.hugePages);
|
||||
|
||||
lock = std::move(std::unique_lock<std::mutex>(m_mutex));
|
||||
|
||||
if (m_state == STATE_SHUTDOWN || !m_queue.empty()) {
|
||||
continue;
|
||||
}
|
||||
|
||||
m_state = STATE_IDLE;
|
||||
uv_async_send(m_async);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void xmrig::RxQueue::onReady()
|
||||
{
|
||||
std::unique_lock<std::mutex> lock(m_mutex);
|
||||
const bool ready = m_listener && m_state == STATE_IDLE;
|
||||
lock.unlock();
|
||||
|
||||
if (ready) {
|
||||
m_listener->onDatasetReady();
|
||||
}
|
||||
}
|
||||
108
src/crypto/rx/RxQueue.h
Normal file
108
src/crypto/rx/RxQueue.h
Normal file
|
|
@ -0,0 +1,108 @@
|
|||
/* XMRig
|
||||
* Copyright 2010 Jeff Garzik <jgarzik@pobox.com>
|
||||
* Copyright 2012-2014 pooler <pooler@litecoinpool.org>
|
||||
* Copyright 2014 Lucas Jones <https://github.com/lucasjones>
|
||||
* Copyright 2014-2016 Wolf9466 <https://github.com/OhGodAPet>
|
||||
* Copyright 2016 Jay D Dee <jayddee246@gmail.com>
|
||||
* Copyright 2017-2019 XMR-Stak <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
|
||||
* Copyright 2018 Lee Clagett <https://github.com/vtnerd>
|
||||
* Copyright 2018-2019 tevador <tevador@gmail.com>
|
||||
* Copyright 2018-2019 SChernykh <https://github.com/SChernykh>
|
||||
* Copyright 2016-2019 XMRig <https://github.com/xmrig>, <support@xmrig.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef XMRIG_RX_QUEUE_H
|
||||
#define XMRIG_RX_QUEUE_H
|
||||
|
||||
|
||||
#include "base/tools/Object.h"
|
||||
#include "crypto/rx/RxSeed.h"
|
||||
|
||||
|
||||
#include <condition_variable>
|
||||
#include <mutex>
|
||||
#include <thread>
|
||||
|
||||
|
||||
using uv_async_t = struct uv_async_s;
|
||||
|
||||
|
||||
namespace xmrig
|
||||
{
|
||||
|
||||
|
||||
class IRxListener;
|
||||
class IRxStorage;
|
||||
class RxDataset;
|
||||
|
||||
|
||||
class RxQueueItem
|
||||
{
|
||||
public:
|
||||
RxQueueItem(const RxSeed &seed, const std::vector<uint32_t> &nodeset, uint32_t threads, bool hugePages) :
|
||||
hugePages(hugePages),
|
||||
seed(seed),
|
||||
nodeset(nodeset),
|
||||
threads(threads)
|
||||
{}
|
||||
|
||||
const bool hugePages;
|
||||
const RxSeed seed;
|
||||
const std::vector<uint32_t> nodeset;
|
||||
const uint32_t threads;
|
||||
};
|
||||
|
||||
|
||||
class RxQueue
|
||||
{
|
||||
public:
|
||||
XMRIG_DISABLE_COPY_MOVE(RxQueue);
|
||||
|
||||
RxQueue(IRxListener *listener);
|
||||
~RxQueue();
|
||||
|
||||
bool isReady(const Job &job);
|
||||
RxDataset *dataset(const Job &job, uint32_t nodeId);
|
||||
std::pair<uint32_t, uint32_t> hugePages();
|
||||
void enqueue(const RxSeed &seed, const std::vector<uint32_t> &nodeset, uint32_t threads, bool hugePages);
|
||||
|
||||
private:
|
||||
enum State {
|
||||
STATE_IDLE,
|
||||
STATE_PENDING,
|
||||
STATE_SHUTDOWN
|
||||
};
|
||||
|
||||
bool isReadyUnsafe(const Job &job) const;
|
||||
void backgroundInit();
|
||||
void onReady();
|
||||
|
||||
IRxListener *m_listener = nullptr;
|
||||
IRxStorage *m_storage = nullptr;
|
||||
RxSeed m_seed;
|
||||
State m_state = STATE_IDLE;
|
||||
std::condition_variable m_cv;
|
||||
std::mutex m_mutex;
|
||||
std::thread m_thread;
|
||||
std::vector<RxQueueItem> m_queue;
|
||||
uv_async_t *m_async = nullptr;
|
||||
};
|
||||
|
||||
|
||||
} /* namespace xmrig */
|
||||
|
||||
|
||||
#endif /* XMRIG_RX_QUEUE_H */
|
||||
69
src/crypto/rx/RxSeed.h
Normal file
69
src/crypto/rx/RxSeed.h
Normal file
|
|
@ -0,0 +1,69 @@
|
|||
/* XMRig
|
||||
* Copyright 2010 Jeff Garzik <jgarzik@pobox.com>
|
||||
* Copyright 2012-2014 pooler <pooler@litecoinpool.org>
|
||||
* Copyright 2014 Lucas Jones <https://github.com/lucasjones>
|
||||
* Copyright 2014-2016 Wolf9466 <https://github.com/OhGodAPet>
|
||||
* Copyright 2016 Jay D Dee <jayddee246@gmail.com>
|
||||
* Copyright 2017-2019 XMR-Stak <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
|
||||
* Copyright 2018 Lee Clagett <https://github.com/vtnerd>
|
||||
* Copyright 2018-2019 tevador <tevador@gmail.com>
|
||||
* Copyright 2018-2019 SChernykh <https://github.com/SChernykh>
|
||||
* Copyright 2016-2019 XMRig <https://github.com/xmrig>, <support@xmrig.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef XMRIG_RX_SEED_H
|
||||
#define XMRIG_RX_SEED_H
|
||||
|
||||
|
||||
#include "base/net/stratum/Job.h"
|
||||
#include "base/tools/Buffer.h"
|
||||
|
||||
|
||||
namespace xmrig
|
||||
{
|
||||
|
||||
|
||||
class RxSeed;
|
||||
|
||||
|
||||
class RxSeed
|
||||
{
|
||||
public:
|
||||
RxSeed() = default;
|
||||
|
||||
inline RxSeed(const Algorithm &algorithm, const Buffer &seed) : m_algorithm(algorithm), m_data(seed) {}
|
||||
inline RxSeed(const Job &job) : m_algorithm(job.algorithm()), m_data(job.seed()) {}
|
||||
|
||||
inline bool isEqual(const Job &job) const { return m_algorithm == job.algorithm() && m_data == job.seed(); }
|
||||
inline bool isEqual(const RxSeed &other) const { return m_algorithm == other.m_algorithm && m_data == other.m_data; }
|
||||
inline const Algorithm &algorithm() const { return m_algorithm; }
|
||||
inline const Buffer &data() const { return m_data; }
|
||||
|
||||
inline bool operator!=(const Job &job) const { return !isEqual(job); }
|
||||
inline bool operator!=(const RxSeed &other) const { return !isEqual(other); }
|
||||
inline bool operator==(const Job &job) const { return isEqual(job); }
|
||||
inline bool operator==(const RxSeed &other) const { return isEqual(other); }
|
||||
|
||||
private:
|
||||
Algorithm m_algorithm;
|
||||
Buffer m_data;
|
||||
};
|
||||
|
||||
|
||||
} /* namespace xmrig */
|
||||
|
||||
|
||||
#endif /* XMRIG_RX_CACHE_H */
|
||||
|
|
@ -41,11 +41,11 @@ xmrig::RxVm::RxVm(RxDataset *dataset, uint8_t *scratchpad, bool softAes)
|
|||
m_flags |= RANDOMX_FLAG_FULL_MEM;
|
||||
}
|
||||
|
||||
if (dataset->cache()->isJIT()) {
|
||||
if (!dataset->cache() || dataset->cache()->isJIT()) {
|
||||
m_flags |= RANDOMX_FLAG_JIT;
|
||||
}
|
||||
|
||||
m_vm = randomx_create_vm(static_cast<randomx_flags>(m_flags), dataset->cache()->get(), dataset->get(), scratchpad);
|
||||
m_vm = randomx_create_vm(static_cast<randomx_flags>(m_flags), dataset->cache() ? dataset->cache()->get() : nullptr, dataset->get(), scratchpad);
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue