From 68d77b02d7d42e5b865bb447541c4c06790b9d3f Mon Sep 17 00:00:00 2001 From: XMRig Date: Mon, 7 Oct 2019 12:36:40 +0700 Subject: [PATCH] Added initial memory pool support. --- CMakeLists.txt | 9 ++ cmake/randomx.cmake | 2 +- src/App.cpp | 3 - src/backend/common/Worker.cpp | 3 +- src/backend/common/Worker.h | 4 +- src/backend/common/interfaces/IMemoryPool.h | 52 +++++++++++ src/backend/cpu/CpuWorker.cpp | 2 +- src/core/Controller.cpp | 15 +++- src/core/config/Config.h | 5 +- src/crypto/common/MemoryPool.cpp | 95 ++++++++++++++++++++ src/crypto/common/MemoryPool.h | 66 ++++++++++++++ src/crypto/common/VirtualMemory.cpp | 98 ++++++++++++++++----- src/crypto/common/VirtualMemory.h | 15 +++- src/crypto/common/VirtualMemory_hwloc.cpp | 56 ++++++++++++ src/crypto/common/VirtualMemory_unix.cpp | 82 ++++++++--------- src/crypto/common/VirtualMemory_win.cpp | 62 ++++++------- src/net/JobResults.cpp | 2 +- 17 files changed, 444 insertions(+), 127 deletions(-) create mode 100644 src/backend/common/interfaces/IMemoryPool.h create mode 100644 src/crypto/common/MemoryPool.cpp create mode 100644 src/crypto/common/MemoryPool.h create mode 100644 src/crypto/common/VirtualMemory_hwloc.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 377a0bf6..5bb2570e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -55,6 +55,7 @@ set(HEADERS ) set(HEADERS_CRYPTO + src/backend/common/interfaces/IMemoryPool.h src/crypto/cn/asm/CryptonightR_template.h src/crypto/cn/c_blake256.h src/crypto/cn/c_groestl.h @@ -73,6 +74,7 @@ set(HEADERS_CRYPTO src/crypto/common/Algorithm.h src/crypto/common/Coin.h src/crypto/common/keccak.h + src/crypto/common/MemoryPool.h src/crypto/common/Nonce.h src/crypto/common/portable/mm_malloc.h src/crypto/common/VirtualMemory.h @@ -111,10 +113,17 @@ set(SOURCES_CRYPTO src/crypto/common/Algorithm.cpp src/crypto/common/Coin.cpp src/crypto/common/keccak.cpp + src/crypto/common/MemoryPool.cpp src/crypto/common/Nonce.cpp src/crypto/common/VirtualMemory.cpp ) +if (WITH_HWLOC) + list(APPEND SOURCES_CRYPTO + src/crypto/common/VirtualMemory_hwloc.cpp + ) +endif() + if (WIN32) set(SOURCES_OS "${SOURCES_OS}" diff --git a/cmake/randomx.cmake b/cmake/randomx.cmake index d05ceb89..290b8391 100644 --- a/cmake/randomx.cmake +++ b/cmake/randomx.cmake @@ -70,7 +70,7 @@ if (WITH_RANDOMX) endif() if (WITH_HWLOC) - list(APPEND SOURCES_CRYPTO + list(APPEND HEADERS_CRYPTO src/crypto/rx/RxNUMAStorage.h ) diff --git a/src/App.cpp b/src/App.cpp index 10b10a0d..7db2ace2 100644 --- a/src/App.cpp +++ b/src/App.cpp @@ -36,7 +36,6 @@ #include "core/config/Config.h" #include "core/Controller.h" #include "core/Miner.h" -#include "crypto/common/VirtualMemory.h" #include "net/Network.h" #include "Summary.h" #include "version.h" @@ -80,8 +79,6 @@ int xmrig::App::exec() m_console = new Console(this); } - VirtualMemory::init(); - Summary::print(m_controller); if (m_controller->config()->isDryRun()) { diff --git a/src/backend/common/Worker.cpp b/src/backend/common/Worker.cpp index 91ef0c7a..d6e01560 100644 --- a/src/backend/common/Worker.cpp +++ b/src/backend/common/Worker.cpp @@ -34,8 +34,7 @@ xmrig::Worker::Worker(size_t id, int64_t affinity, int priority) : m_affinity(affinity), m_id(id), m_hashCount(0), - m_timestamp(0), - m_count(0) + m_timestamp(0) { m_node = VirtualMemory::bindToNUMANode(affinity); diff --git a/src/backend/common/Worker.h b/src/backend/common/Worker.h index f55ec8aa..2cdae3fc 100644 --- a/src/backend/common/Worker.h +++ b/src/backend/common/Worker.h @@ -54,8 +54,8 @@ protected: const size_t m_id; std::atomic m_hashCount; std::atomic m_timestamp; - uint32_t m_node = 0; - uint64_t m_count; + uint32_t m_node = 0; + uint64_t m_count = 0; }; diff --git a/src/backend/common/interfaces/IMemoryPool.h b/src/backend/common/interfaces/IMemoryPool.h new file mode 100644 index 00000000..869bad32 --- /dev/null +++ b/src/backend/common/interfaces/IMemoryPool.h @@ -0,0 +1,52 @@ +/* XMRig + * Copyright 2010 Jeff Garzik + * Copyright 2012-2014 pooler + * Copyright 2014 Lucas Jones + * Copyright 2014-2016 Wolf9466 + * Copyright 2016 Jay D Dee + * Copyright 2017-2018 XMR-Stak , + * Copyright 2018 Lee Clagett + * Copyright 2018-2019 SChernykh + * Copyright 2018-2019 tevador + * Copyright 2016-2019 XMRig , + * + * 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 . + */ + +#ifndef XMRIG_IMEMORYPOOL_H +#define XMRIG_IMEMORYPOOL_H + + +#include + + +namespace xmrig { + + +class IMemoryPool +{ +public: + virtual ~IMemoryPool() = default; + + virtual bool isHugePages(uint32_t node) const = 0; + virtual uint8_t *get(size_t size, uint32_t node) = 0; + virtual void release(uint32_t node) = 0; +}; + + +} /* namespace xmrig */ + + + +#endif /* XMRIG_IMEMORYPOOL_H */ diff --git a/src/backend/cpu/CpuWorker.cpp b/src/backend/cpu/CpuWorker.cpp index 22651c35..d993e6e6 100644 --- a/src/backend/cpu/CpuWorker.cpp +++ b/src/backend/cpu/CpuWorker.cpp @@ -62,7 +62,7 @@ xmrig::CpuWorker::CpuWorker(size_t id, const CpuLaunchData &data) : m_miner(data.miner), m_ctx() { - m_memory = new VirtualMemory(m_algorithm.l3() * N, data.hugePages); + m_memory = new VirtualMemory(m_algorithm.l3() * N, data.hugePages, true); } diff --git a/src/core/Controller.cpp b/src/core/Controller.cpp index 80381e32..75a3e51b 100644 --- a/src/core/Controller.cpp +++ b/src/core/Controller.cpp @@ -23,15 +23,17 @@ */ -#include - - -#include "backend/cpu/Cpu.h" #include "core/Controller.h" +#include "backend/cpu/Cpu.h" +#include "core/config/Config.h" #include "core/Miner.h" +#include "crypto/common/VirtualMemory.h" #include "net/Network.h" +#include + + xmrig::Controller::Controller(Process *process) : Base(process) { @@ -41,6 +43,8 @@ xmrig::Controller::Controller(Process *process) : xmrig::Controller::~Controller() { delete m_network; + + VirtualMemory::destroy(); } @@ -48,7 +52,10 @@ int xmrig::Controller::init() { Base::init(); + VirtualMemory::init(config()->cpu().isHugePages(), -1); + m_network = new Network(this); + return 0; } diff --git a/src/core/config/Config.h b/src/core/config/Config.h index 7c7bc533..22deb2c2 100644 --- a/src/core/config/Config.h +++ b/src/core/config/Config.h @@ -26,11 +26,12 @@ #define XMRIG_CONFIG_H -#include +#include #include "backend/cpu/CpuConfig.h" #include "base/kernel/config/BaseConfig.h" +#include "base/tools/Object.h" #include "rapidjson/fwd.h" @@ -46,6 +47,8 @@ class OclConfig; class Config : public BaseConfig { public: + XMRIG_DISABLE_COPY_MOVE(Config); + Config(); ~Config() override; diff --git a/src/crypto/common/MemoryPool.cpp b/src/crypto/common/MemoryPool.cpp new file mode 100644 index 00000000..475655b1 --- /dev/null +++ b/src/crypto/common/MemoryPool.cpp @@ -0,0 +1,95 @@ +/* XMRig + * Copyright 2010 Jeff Garzik + * Copyright 2012-2014 pooler + * Copyright 2014 Lucas Jones + * Copyright 2014-2016 Wolf9466 + * Copyright 2016 Jay D Dee + * Copyright 2017-2018 XMR-Stak , + * Copyright 2018 Lee Clagett + * Copyright 2018-2019 SChernykh + * Copyright 2018-2019 tevador + * Copyright 2016-2019 XMRig , + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + + +#include "crypto/common/MemoryPool.h" +#include "crypto/common/VirtualMemory.h" + + +#include + + +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; + } +} diff --git a/src/crypto/common/MemoryPool.h b/src/crypto/common/MemoryPool.h new file mode 100644 index 00000000..b5bd1020 --- /dev/null +++ b/src/crypto/common/MemoryPool.h @@ -0,0 +1,66 @@ +/* XMRig + * Copyright 2010 Jeff Garzik + * Copyright 2012-2014 pooler + * Copyright 2014 Lucas Jones + * Copyright 2014-2016 Wolf9466 + * Copyright 2016 Jay D Dee + * Copyright 2017-2018 XMR-Stak , + * Copyright 2018 Lee Clagett + * Copyright 2018-2019 SChernykh + * Copyright 2018-2019 tevador + * Copyright 2016-2019 XMRig , + * + * 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 . + */ + +#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 */ diff --git a/src/crypto/common/VirtualMemory.cpp b/src/crypto/common/VirtualMemory.cpp index 242f32a2..332c07fd 100644 --- a/src/crypto/common/VirtualMemory.cpp +++ b/src/crypto/common/VirtualMemory.cpp @@ -25,41 +25,91 @@ */ -#ifdef XMRIG_FEATURE_HWLOC -# include -# include "backend/cpu/platform/HwlocCpuInfo.h" -#endif - - #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" #include +#include -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 || Cpu::info()->nodes() < 2) { - return 0; + if (usePool) { + std::lock_guard lock(mutex); + if (hugePages && !pool->isHugePages(node) && allocateLargePagesMemory()) { + return; + } + + m_scratchpad = pool->get(m_size, node); + if (m_scratchpad) { + m_flags.set(FLAG_HUGEPAGES, pool->isHugePages(node)); + m_flags.set(FLAG_EXTERNAL, true); + + return; + } } - auto cpu = static_cast(Cpu::info()); - hwloc_obj_t pu = hwloc_get_pu_obj_by_os_index(cpu->topology(), static_cast(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; + if (hugePages && allocateLargePagesMemory()) { + return; } - return hwloc_bitmap_first(pu->nodeset); -# else - return 0; -# endif + m_scratchpad = static_cast(_mm_malloc(m_size, alignSize)); +} + + +xmrig::VirtualMemory::~VirtualMemory() +{ + if (!m_scratchpad) { + return; + } + + if (m_flags.test(FLAG_EXTERNAL)) { + std::lock_guard lock(mutex); + pool->release(m_node); + } + + 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(bool hugePages, int poolSize) +{ + if (!pool) { + osInit(); + } + + pool = new MemoryPool(poolSize < 0 ? Cpu::info()->threads() : poolSize, hugePages); } diff --git a/src/crypto/common/VirtualMemory.h b/src/crypto/common/VirtualMemory.h index e8c9dbad..668ae907 100644 --- a/src/crypto/common/VirtualMemory.h +++ b/src/crypto/common/VirtualMemory.h @@ -45,7 +45,7 @@ class VirtualMemory public: XMRIG_DISABLE_COPY_MOVE_DEFAULT(VirtualMemory) - VirtualMemory(size_t size, bool hugePages = true, size_t align = 64); + VirtualMemory(size_t size, bool hugePages, bool usePool, uint32_t node = 0, size_t alignSize = 64); ~VirtualMemory(); inline bool isHugePages() const { return m_flags.test(FLAG_HUGEPAGES); } @@ -61,9 +61,10 @@ public: 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(); + static void init(bool hugePages, int poolSize); static void protectExecutableMemory(void *p, size_t size); static void unprotectExecutableMemory(void *p, size_t size); @@ -77,9 +78,15 @@ private: FLAG_MAX }; + static void osInit(); + + bool allocateLargePagesMemory(); + void freeLargePagesMemory(); + + const size_t m_size; + const uint32_t m_node; std::bitset m_flags; - size_t m_size = 0; - uint8_t *m_scratchpad = nullptr; + uint8_t *m_scratchpad = nullptr; }; diff --git a/src/crypto/common/VirtualMemory_hwloc.cpp b/src/crypto/common/VirtualMemory_hwloc.cpp new file mode 100644 index 00000000..6ccc0c23 --- /dev/null +++ b/src/crypto/common/VirtualMemory_hwloc.cpp @@ -0,0 +1,56 @@ +/* XMRig + * Copyright 2010 Jeff Garzik + * Copyright 2012-2014 pooler + * Copyright 2014 Lucas Jones + * Copyright 2014-2016 Wolf9466 + * Copyright 2016 Jay D Dee + * Copyright 2017-2018 XMR-Stak , + * Copyright 2018 Lee Clagett + * Copyright 2018-2019 SChernykh + * Copyright 2018-2019 tevador + * Copyright 2016-2019 XMRig , + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + + +#include "crypto/common/VirtualMemory.h" +#include "backend/cpu/Cpu.h" +#include "backend/cpu/platform/HwlocCpuInfo.h" +#include "base/io/log/Log.h" + + +#include + + +uint32_t xmrig::VirtualMemory::bindToNUMANode(int64_t affinity) +{ + if (affinity < 0 || Cpu::info()->nodes() < 2) { + return 0; + } + + auto cpu = static_cast(Cpu::info()); + hwloc_obj_t pu = hwloc_get_pu_obj_by_os_index(cpu->topology(), static_cast(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); +} diff --git a/src/crypto/common/VirtualMemory_unix.cpp b/src/crypto/common/VirtualMemory_unix.cpp index 14059f03..8a66c34d 100644 --- a/src/crypto/common/VirtualMemory_unix.cpp +++ b/src/crypto/common/VirtualMemory_unix.cpp @@ -25,7 +25,7 @@ */ -#include +#include #include @@ -38,47 +38,6 @@ #endif -xmrig::VirtualMemory::VirtualMemory(size_t size, bool hugePages, size_t align) : - m_size(VirtualMemory::align(size)) -{ - if (hugePages) { - m_scratchpad = static_cast(allocateLargePagesMemory(m_size)); - if (m_scratchpad) { - m_flags.set(FLAG_HUGEPAGES, true); - - madvise(m_scratchpad, size, MADV_RANDOM | MADV_WILLNEED); - - if (mlock(m_scratchpad, m_size) == 0) { - m_flags.set(FLAG_LOCK, true); - } - - return; - } - } - - m_scratchpad = static_cast(_mm_malloc(m_size, align)); -} - - -xmrig::VirtualMemory::~VirtualMemory() -{ - if (!m_scratchpad) { - return; - } - - if (isHugePages()) { - if (m_flags.test(FLAG_LOCK)) { - munlock(m_scratchpad, m_size); - } - - freeLargePagesMemory(m_scratchpad, m_size); - } - else { - _mm_free(m_scratchpad); - } -} - - bool xmrig::VirtualMemory::isHugepagesAvailable() { return true; @@ -125,11 +84,6 @@ void xmrig::VirtualMemory::freeLargePagesMemory(void *p, size_t size) } -void xmrig::VirtualMemory::init() -{ -} - - void xmrig::VirtualMemory::protectExecutableMemory(void *p, size_t size) { mprotect(p, size, PROT_READ | PROT_EXEC); @@ -140,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(allocateLargePagesMemory(m_size)); + if (m_scratchpad) { + m_flags.set(FLAG_HUGEPAGES, true); + + madvise(m_scratchpad, 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); +} diff --git a/src/crypto/common/VirtualMemory_win.cpp b/src/crypto/common/VirtualMemory_win.cpp index 9dbf9041..875a1e8e 100644 --- a/src/crypto/common/VirtualMemory_win.cpp +++ b/src/crypto/common/VirtualMemory_win.cpp @@ -150,37 +150,6 @@ static BOOL TrySetLockPagesPrivilege() { } // namespace xmrig -xmrig::VirtualMemory::VirtualMemory(size_t size, bool hugePages, size_t align) : - m_size(VirtualMemory::align(size)) -{ - if (hugePages) { - m_scratchpad = static_cast(allocateLargePagesMemory(m_size)); - if (m_scratchpad) { - m_flags.set(FLAG_HUGEPAGES, true); - - return; - } - } - - m_scratchpad = static_cast(_mm_malloc(m_size, align)); -} - - -xmrig::VirtualMemory::~VirtualMemory() -{ - if (!m_scratchpad) { - return; - } - - if (isHugePages()) { - freeLargePagesMemory(m_scratchpad, m_size); - } - else { - _mm_free(m_scratchpad); - } -} - - bool xmrig::VirtualMemory::isHugepagesAvailable() { return hugepagesAvailable; @@ -218,12 +187,6 @@ void xmrig::VirtualMemory::freeLargePagesMemory(void *p, size_t) } -void xmrig::VirtualMemory::init() -{ - hugepagesAvailable = TrySetLockPagesPrivilege(); -} - - void xmrig::VirtualMemory::protectExecutableMemory(void *p, size_t size) { DWORD oldProtect; @@ -236,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(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); +} diff --git a/src/net/JobResults.cpp b/src/net/JobResults.cpp index c6bd68bb..e8b4adce 100644 --- a/src/net/JobResults.cpp +++ b/src/net/JobResults.cpp @@ -105,7 +105,7 @@ static inline void checkHash(const JobBundle &bundle, std::vector &re static void getResults(JobBundle &bundle, std::vector &results, uint32_t &errors, bool hwAES) { const auto &algorithm = bundle.job.algorithm(); - auto memory = new VirtualMemory(algorithm.l3(), false); + auto memory = new VirtualMemory(algorithm.l3(), false, false); uint8_t hash[32]{ 0 }; if (algorithm.family() == Algorithm::RANDOM_X) {