Cypher_Stack/RandomWOW
2
0
Fork 0
mirror of https://git.wownero.com/wownero/RandomWOW.git synced 2024-12-22 15:58:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

Dataset size increased to 2080 MiB

Browse Source 
Implemented dataset base offset
Tweaked SuperscalarHash constants to prevent register collisions
This commit is contained in:
tevador 2019-04-26 16:05:30 +02:00
parent f66da3911e
commit 270a4f97fe
19 changed files with 56 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/asm/program_read_dataset_sshash_init.inc
View File

@ -13,4 +13,5 @@
mov ebx, ebp ;# ecx = ma mov ebx, ebp ;# ecx = ma
and ebx, 2147483584 ;# align "ma" to the start of a cache line and ebx, 2147483584 ;# align "ma" to the start of a cache line
shr ebx, 6 ;# ebx = Dataset block number shr ebx, 6 ;# ebx = Dataset block number
;# add ebx, datasetOffset / 64
;# call 32768 ;# call 32768

8
src/asm/program_sshash_constants.inc
View File

@ -2,14 +2,14 @@ r0_mul:
;#/ 6364136223846793005 ;#/ 6364136223846793005
db 45, 127, 149, 76, 45, 244, 81, 88 db 45, 127, 149, 76, 45, 244, 81, 88
r1_add: r1_add:
;#/ 9298410992540426748 ;#/ 9298411001130361340
db 252, 161, 245, 89, 136, 151, 10, 129 db 252, 161, 245, 89, 138, 151, 10, 129
r2_add: r2_add:
;#/ 12065312585734608966 ;#/ 12065312585734608966
db 70, 216, 194, 56, 223, 153, 112, 167 db 70, 216, 194, 56, 223, 153, 112, 167
r3_add: r3_add:
;#/ 9306329213124610396 ;#/ 9306329213124626780
db 92, 9, 34, 191, 28, 185, 38, 129 db 92, 73, 34, 191, 28, 185, 38, 129
r4_add: r4_add:
;#/ 5281919268842080866 ;#/ 5281919268842080866
db 98, 138, 159, 23, 151, 37, 77, 73 db 98, 138, 159, 23, 151, 37, 77, 73

11
src/common.hpp
View File

@ -28,8 +28,9 @@ along with RandomX. If not, see<http://www.gnu.org/licenses/>.
namespace randomx { namespace randomx {
static_assert((RANDOMX_ARGON_MEMORY & (RANDOMX_ARGON_MEMORY - 1)) == 0, "RANDOMX_ARGON_MEMORY must be a power of 2."); static_assert((RANDOMX_ARGON_MEMORY & (RANDOMX_ARGON_MEMORY - 1)) == 0, "RANDOMX_ARGON_MEMORY must be a power of 2.");
static_assert((RANDOMX_DATASET_SIZE & (RANDOMX_DATASET_SIZE - 1)) == 0, "RANDOMX_DATASET_SIZE must be a power of 2."); static_assert((RANDOMX_DATASET_BASE_SIZE & (RANDOMX_DATASET_BASE_SIZE - 1)) == 0, "RANDOMX_DATASET_BASE_SIZE must be a power of 2.");
static_assert(RANDOMX_DATASET_SIZE <= 4294967296ULL, "RANDOMX_DATASET_SIZE must not exceed 4294967296."); static_assert(RANDOMX_DATASET_BASE_SIZE <= 4294967296ULL, "RANDOMX_DATASET_BASE_SIZE must not exceed 4294967296.");
static_assert(RANDOMX_DATASET_EXTRA_SIZE % 64 == 0, "RANDOMX_DATASET_EXTRA_SIZE must be divisible by 64.");
static_assert(RANDOMX_PROGRAM_SIZE > 0, "RANDOMX_PROGRAM_SIZE must be greater than 0"); static_assert(RANDOMX_PROGRAM_SIZE > 0, "RANDOMX_PROGRAM_SIZE must be greater than 0");
static_assert(RANDOMX_PROGRAM_ITERATIONS > 0, "RANDOMX_PROGRAM_ITERATIONS must be greater than 0"); static_assert(RANDOMX_PROGRAM_ITERATIONS > 0, "RANDOMX_PROGRAM_ITERATIONS must be greater than 0");
static_assert(RANDOMX_PROGRAM_COUNT > 0, "RANDOMX_PROGRAM_COUNT must be greater than 0"); static_assert(RANDOMX_PROGRAM_COUNT > 0, "RANDOMX_PROGRAM_COUNT must be greater than 0");
@ -56,8 +57,10 @@ namespace randomx {
constexpr int ArgonSaltSize = sizeof(RANDOMX_ARGON_SALT) - 1; constexpr int ArgonSaltSize = sizeof(RANDOMX_ARGON_SALT) - 1;
constexpr int CacheLineSize = RANDOMX_DATASET_ITEM_SIZE; constexpr int CacheLineSize = RANDOMX_DATASET_ITEM_SIZE;
constexpr int ScratchpadSize = RANDOMX_SCRATCHPAD_L3; constexpr int ScratchpadSize = RANDOMX_SCRATCHPAD_L3;
constexpr uint32_t CacheLineAlignMask = (RANDOMX_DATASET_SIZE - 1) & ~(CacheLineSize - 1); constexpr uint32_t CacheLineAlignMask = (RANDOMX_DATASET_BASE_SIZE - 1) & ~(CacheLineSize - 1);
constexpr uint32_t CacheSize = RANDOMX_ARGON_MEMORY * 1024; constexpr uint32_t CacheSize = RANDOMX_ARGON_MEMORY * ArgonBlockSize;
constexpr uint64_t DatasetSize = RANDOMX_DATASET_BASE_SIZE + RANDOMX_DATASET_EXTRA_SIZE;
constexpr uint32_t DatasetExtraItems = RANDOMX_DATASET_EXTRA_SIZE / RANDOMX_DATASET_ITEM_SIZE;
#ifdef TRACE #ifdef TRACE
constexpr bool trace = true; constexpr bool trace = true;

7
src/configuration.h
View File

@ -37,8 +37,11 @@ along with RandomX. If not, see<http://www.gnu.org/licenses/>.
#define RANDOMX_SUPERSCALAR_LATENCY 170 #define RANDOMX_SUPERSCALAR_LATENCY 170
#define RANDOMX_SUPERSCALAR_MAX_SIZE 512 #define RANDOMX_SUPERSCALAR_MAX_SIZE 512
//Dataset size in bytes. Must be a power of 2. //Dataset base size in bytes. Must be a power of 2.
#define RANDOMX_DATASET_SIZE (2ULL * 1024 * 1024 * 1024) #define RANDOMX_DATASET_BASE_SIZE (2ULL * 1024 * 1024 * 1024)
//Dataset extra size. Must be divisible by 64.
#define RANDOMX_DATASET_EXTRA_SIZE 33554368
//Number of instructions in a RandomX program //Number of instructions in a RandomX program
#define RANDOMX_PROGRAM_SIZE 256 #define RANDOMX_PROGRAM_SIZE 256

15
src/dataset.cpp
View File

@ -45,6 +45,7 @@ randomx_dataset::~randomx_dataset() {
} }
static_assert(RANDOMX_ARGON_MEMORY % (RANDOMX_ARGON_LANES * ARGON2_SYNC_POINTS) == 0, "RANDOMX_ARGON_MEMORY - invalid value"); static_assert(RANDOMX_ARGON_MEMORY % (RANDOMX_ARGON_LANES * ARGON2_SYNC_POINTS) == 0, "RANDOMX_ARGON_MEMORY - invalid value");
static_assert(ARGON2_BLOCK_SIZE == randomx::ArgonBlockSize, "Unpexpected value of ARGON2_BLOCK_SIZE");
void randomx_cache::initialize(const void *seed, size_t seedSize) { void randomx_cache::initialize(const void *seed, size_t seedSize) {
uint32_t memory_blocks, segment_length; uint32_t memory_blocks, segment_length;
@ -117,22 +118,22 @@ namespace randomx {
template<class Allocator> template<class Allocator>
void Dataset<Allocator>::allocate() { void Dataset<Allocator>::allocate() {
memory = (uint8_t*)Allocator::allocMemory(RANDOMX_DATASET_SIZE); memory = (uint8_t*)Allocator::allocMemory(DatasetSize);
} }
template<class Allocator> template<class Allocator>
Dataset<Allocator>::~Dataset() { Dataset<Allocator>::~Dataset() {
Allocator::freeMemory(memory, RANDOMX_DATASET_SIZE); Allocator::freeMemory(memory, DatasetSize);
} }
template<class Allocator> template<class Allocator>
void Cache<Allocator>::allocate() { void Cache<Allocator>::allocate() {
memory = (uint8_t*)Allocator::allocMemory(RANDOMX_ARGON_MEMORY * ARGON2_BLOCK_SIZE); memory = (uint8_t*)Allocator::allocMemory(CacheSize);
} }
template<class Allocator> template<class Allocator>
Cache<Allocator>::~Cache() { Cache<Allocator>::~Cache() {
Allocator::freeMemory(memory, RANDOMX_ARGON_MEMORY * ARGON2_BLOCK_SIZE); Allocator::freeMemory(memory, CacheSize);
} }
template<class Allocator> template<class Allocator>
@ -160,16 +161,16 @@ namespace randomx {
template class CacheWithJit<LargePageAllocator>; template class CacheWithJit<LargePageAllocator>;
constexpr uint64_t superscalarMul0 = 6364136223846793005ULL; constexpr uint64_t superscalarMul0 = 6364136223846793005ULL;
constexpr uint64_t superscalarAdd1 = 9298410992540426748ULL; constexpr uint64_t superscalarAdd1 = 9298411001130361340ULL;
constexpr uint64_t superscalarAdd2 = 12065312585734608966ULL; constexpr uint64_t superscalarAdd2 = 12065312585734608966ULL;
constexpr uint64_t superscalarAdd3 = 9306329213124610396ULL; constexpr uint64_t superscalarAdd3 = 9306329213124626780ULL;
constexpr uint64_t superscalarAdd4 = 5281919268842080866ULL; constexpr uint64_t superscalarAdd4 = 5281919268842080866ULL;
constexpr uint64_t superscalarAdd5 = 10536153434571861004ULL; constexpr uint64_t superscalarAdd5 = 10536153434571861004ULL;
constexpr uint64_t superscalarAdd6 = 3398623926847679864ULL; constexpr uint64_t superscalarAdd6 = 3398623926847679864ULL;
constexpr uint64_t superscalarAdd7 = 9549104520008361294ULL; constexpr uint64_t superscalarAdd7 = 9549104520008361294ULL;
static inline uint8_t* getMixBlock(uint64_t registerValue, uint8_t *memory) { static inline uint8_t* getMixBlock(uint64_t registerValue, uint8_t *memory) {
constexpr uint32_t mask = (RANDOMX_ARGON_MEMORY * ArgonBlockSize / CacheLineSize - 1); constexpr uint32_t mask = CacheSize / CacheLineSize - 1;
return memory + (registerValue & mask) * CacheLineSize; return memory + (registerValue & mask) * CacheLineSize;
} }

5
src/jit_compiler_x86.cpp
View File

@ -217,6 +217,7 @@ namespace randomx {
static const uint8_t RET = 0xc3; static const uint8_t RET = 0xc3;
static const uint8_t LEA_32[] = { 0x67, 0x41, 0x8d }; static const uint8_t LEA_32[] = { 0x67, 0x41, 0x8d };
static const uint8_t MOVNTI[] = { 0x4c, 0x0f, 0xc3 }; static const uint8_t MOVNTI[] = { 0x4c, 0x0f, 0xc3 };
static const uint8_t ADD_EBX_I[] = { 0x81, 0xc3 };
static const uint8_t NOP1[] = { 0x90 }; static const uint8_t NOP1[] = { 0x90 };
static const uint8_t NOP2[] = { 0x66, 0x90 }; static const uint8_t NOP2[] = { 0x66, 0x90 };
@ -250,9 +251,11 @@ namespace randomx {
generateProgramEpilogue(prog); generateProgramEpilogue(prog);
} }
void JitCompilerX86::generateProgramLight(Program& prog, ProgramConfiguration& pcfg) { void JitCompilerX86::generateProgramLight(Program& prog, ProgramConfiguration& pcfg, uint32_t datasetOffset) {
generateProgramPrologue(prog, pcfg); generateProgramPrologue(prog, pcfg);
emit(codeReadDatasetLightSshInit, readDatasetLightInitSize); emit(codeReadDatasetLightSshInit, readDatasetLightInitSize);
emit(ADD_EBX_I);
emit32(datasetOffset / CacheLineSize);
emitByte(CALL); emitByte(CALL);
emit32(superScalarHashOffset - (codePos + 4)); emit32(superScalarHashOffset - (codePos + 4));
emit(codeReadDatasetLightSshFin, readDatasetLightFinSize); emit(codeReadDatasetLightSshFin, readDatasetLightFinSize);

2
src/jit_compiler_x86.hpp
View File

@ -41,7 +41,7 @@ namespace randomx {
JitCompilerX86(); JitCompilerX86();
~JitCompilerX86(); ~JitCompilerX86();
void generateProgram(Program&, ProgramConfiguration&); void generateProgram(Program&, ProgramConfiguration&);
void generateProgramLight(Program&, ProgramConfiguration&); void generateProgramLight(Program&, ProgramConfiguration&, uint32_t);
template<size_t N> template<size_t N>
void generateSuperscalarHash(SuperscalarProgram (&programs)[N], std::vector<uint64_t> &); void generateSuperscalarHash(SuperscalarProgram (&programs)[N], std::vector<uint64_t> &);
void generateDatasetInitCode(); void generateDatasetInitCode();

2
src/randomx.cpp
View File

@ -91,7 +91,7 @@ extern "C" {
} }
unsigned long randomx_dataset_item_count() { unsigned long randomx_dataset_item_count() {
return RANDOMX_DATASET_SIZE / RANDOMX_DATASET_ITEM_SIZE; return randomx::DatasetSize / RANDOMX_DATASET_ITEM_SIZE;
} }
void randomx_init_dataset(randomx_dataset *dataset, randomx_cache *cache, unsigned long startItem, unsigned long itemCount) { void randomx_init_dataset(randomx_dataset *dataset, randomx_cache *cache, unsigned long startItem, unsigned long itemCount) {

2
src/tests/benchmark.cpp
View File

@ -225,7 +225,7 @@ int main(int argc, char** argv) {
std::cout << "Calculated result: "; std::cout << "Calculated result: ";
result.print(std::cout); result.print(std::cout);
if (noncesCount == 1000 && seedValue == 0) if (noncesCount == 1000 && seedValue == 0)
std::cout << "Reference result: b69741719152625854031c2337ceae68c3030f2b9581a73acebaa69fc9b555fc" << std::endl; std::cout << "Reference result: 918a8bc3ce0e537eec9d3c5e1a8bb3204ae3954f14c50c14810b38e49588a9e0" << std::endl;
if (!miningMode) { if (!miningMode) {
std::cout << "Performance: " << 1000 * elapsed / noncesCount << " ms per hash" << std::endl; std::cout << "Performance: " << 1000 * elapsed / noncesCount << " ms per hash" << std::endl;
} }

26
src/tests/superscalar-init.cpp
View File

@ -24,27 +24,25 @@ along with RandomX. If not, see<http://www.gnu.org/licenses/>.
#include "../superscalar.hpp" #include "../superscalar.hpp"
#include "../common.hpp" #include "../common.hpp"
const uint8_t seed[32] = { 191, 182, 222, 175, 249, 89, 134, 104, 241, 68, 191, 62, 162, 166, 61, 64, 123, 191, 227, 193, 118, 60, 188, 53, 223, 133, 175, 24, 123, 230, 55, 74 };
int main() { int main() {
std::cout << "THIS PROGRAM REQUIRES MORE THAN 10 GB OF RAM TO COMPLETE" << std::endl; std::cout << "THIS PROGRAM REQUIRES MORE THAN 16 GB OF RAM TO COMPLETE" << std::endl;
std::vector<uint64_t> dummy; std::vector<uint64_t> dummy;
constexpr uint64_t superscalarMul0 = 6364136223846793005ULL; constexpr uint64_t superscalarMul0 = 6364136223846793005ULL;
constexpr uint64_t superscalarAdd1 = 9298410992540426748ULL; //9298410992540426048ULL constexpr uint64_t superscalarAdd1 = 0x810A978A59F5A1FC; //9298410992540426748ULL; //9298410992540426048ULL
constexpr uint64_t superscalarAdd2 = 12065312585734608966ULL; constexpr uint64_t superscalarAdd2 = 12065312585734608966ULL;
constexpr uint64_t superscalarAdd3 = 9306329213124610396ULL; constexpr uint64_t superscalarAdd3 = 0x8126B91CBF22495C; //9306329213124610396ULL;
constexpr uint64_t superscalarAdd4 = 5281919268842080866ULL; constexpr uint64_t superscalarAdd4 = 5281919268842080866ULL;
constexpr uint64_t superscalarAdd5 = 10536153434571861004ULL; constexpr uint64_t superscalarAdd5 = 10536153434571861004ULL;
constexpr uint64_t superscalarAdd6 = 3398623926847679864ULL; constexpr uint64_t superscalarAdd6 = 3398623926847679864ULL;
constexpr uint64_t superscalarAdd7 = 9549104520008361294ULL; constexpr uint64_t superscalarAdd7 = 9549104520008361294ULL;
constexpr uint32_t totalBlocks = RANDOMX_DATASET_SIZE / randomx::CacheLineSize; constexpr uint32_t totalItems = randomx::DatasetSize / randomx::CacheLineSize;
std::unordered_set<uint64_t> registerValues; std::unordered_set<uint64_t> registerValues;
registerValues.reserve(totalBlocks); registerValues.reserve(totalItems);
registerValues.rehash(totalBlocks); registerValues.rehash(totalItems);
int collisionCount[9] = { 0 }; int collisionCount[9] = { 0 };
for (uint32_t blockNumber = 0; blockNumber < totalBlocks; ++blockNumber) { for (uint32_t itemNumber = 0; itemNumber < totalItems; ++itemNumber) {
uint64_t rl[8]; uint64_t rl[8];
rl[0] = (blockNumber + 1) * superscalarMul0; rl[0] = (itemNumber + 1) * superscalarMul0;
rl[1] = rl[0] ^ superscalarAdd1; rl[1] = rl[0] ^ superscalarAdd1;
rl[2] = rl[0] ^ superscalarAdd2; rl[2] = rl[0] ^ superscalarAdd2;
rl[3] = rl[0] ^ superscalarAdd3; rl[3] = rl[0] ^ superscalarAdd3;
@ -57,19 +55,19 @@ int main() {
uint64_t reducedValue = rl[i] & 0x3FFFFFFFFFFFF8; //bits 3-53 only uint64_t reducedValue = rl[i] & 0x3FFFFFFFFFFFF8; //bits 3-53 only
if (registerValues.find(reducedValue) != registerValues.end()) { if (registerValues.find(reducedValue) != registerValues.end()) {
blockCollisions++; blockCollisions++;
std::cout << "Block " << blockNumber << ": collision of register r" << i << std::endl; std::cout << "Item " << itemNumber << ": collision of register r" << i << std::endl;
} }
else { else {
registerValues.insert(reducedValue); registerValues.insert(reducedValue);
} }
} }
collisionCount[blockCollisions]++; collisionCount[blockCollisions]++;
if ((blockNumber % (320 * 1024)) == 0) if ((itemNumber % (320 * 1024)) == 0)
std::cout << "Block " << blockNumber << " processed" << std::endl; std::cout << "Item " << itemNumber << " processed" << std::endl;
} }
for (int i = 0; i < 9; ++i) { for (int i = 0; i < 9; ++i) {
std::cout << i << " register(s) collide in " << collisionCount[i] << " blocks" << std::endl; std::cout << i << " register(s) collide in " << collisionCount[i] << " items" << std::endl;
} }
return 0; return 0;

2
src/virtual_machine.cpp
View File

@ -69,7 +69,7 @@ void randomx_vm::initialize() {
config.readReg2 = 4 + (addressRegisters & 1); config.readReg2 = 4 + (addressRegisters & 1);
addressRegisters >>= 1; addressRegisters >>= 1;
config.readReg3 = 6 + (addressRegisters & 1); config.readReg3 = 6 + (addressRegisters & 1);
//datasetBase = program.getEntropy(13) % datasetRange; datasetOffset = (program.getEntropy(13) & randomx::DatasetExtraItems) * randomx::CacheLineSize;
constexpr uint64_t mask22bit = (1ULL << 22) - 1; constexpr uint64_t mask22bit = (1ULL << 22) - 1;
constexpr uint64_t maskExp240 = ieee_get_exponent_mask<-240>(); constexpr uint64_t maskExp240 = ieee_get_exponent_mask<-240>();
store64(&config.eMask[0], (program.getEntropy(14) & mask22bit) | maskExp240); store64(&config.eMask[0], (program.getEntropy(14) & mask22bit) | maskExp240);

2
src/virtual_machine.hpp
View File

@ -44,6 +44,8 @@ protected:
alignas(16) randomx::ProgramConfiguration config; alignas(16) randomx::ProgramConfiguration config;
randomx::MemoryRegisters mem; randomx::MemoryRegisters mem;
uint8_t* scratchpad; uint8_t* scratchpad;
uint8_t* datasetBasePtr;
uint32_t datasetOffset;
}; };
namespace randomx { namespace randomx {

4
src/vm_compiled.cpp
View File

@ -28,7 +28,7 @@ namespace randomx {
template<class Allocator, bool softAes> template<class Allocator, bool softAes>
void CompiledVm<Allocator, softAes>::setDataset(randomx_dataset* dataset) { void CompiledVm<Allocator, softAes>::setDataset(randomx_dataset* dataset) {
mem.memory = dataset->memory; mem.memory = dataset->memory;
//datasetBasePtr = dataset.memory; datasetBasePtr = dataset->memory;
} }
template<class Allocator, bool softAes> template<class Allocator, bool softAes>
@ -36,7 +36,7 @@ namespace randomx {
VmBase<Allocator, softAes>::generateProgram(seed); VmBase<Allocator, softAes>::generateProgram(seed);
randomx_vm::initialize(); randomx_vm::initialize();
compiler.generateProgram(program, config); compiler.generateProgram(program, config);
//mem.memory = datasetBasePtr + (datasetBase * CacheLineSize); mem.memory = datasetBasePtr + datasetOffset;
execute(); execute();
} }

3
src/vm_compiled.hpp
View File

@ -48,11 +48,12 @@ namespace randomx {
using VmBase<Allocator, softAes>::config; using VmBase<Allocator, softAes>::config;
using VmBase<Allocator, softAes>::reg; using VmBase<Allocator, softAes>::reg;
using VmBase<Allocator, softAes>::scratchpad; using VmBase<Allocator, softAes>::scratchpad;
using VmBase<Allocator, softAes>::datasetBasePtr;
using VmBase<Allocator, softAes>::datasetOffset;
protected: protected:
void execute(); void execute();
JitCompilerX86 compiler; JitCompilerX86 compiler;
uint8_t* datasetBasePtr;
}; };
using CompiledVmDefault = CompiledVm<AlignedAllocator<CacheLineSize>, true>; using CompiledVmDefault = CompiledVm<AlignedAllocator<CacheLineSize>, true>;

4
src/vm_compiled_light.cpp
View File

@ -27,15 +27,13 @@ namespace randomx {
void CompiledLightVm<Allocator, softAes>::setCache(randomx_cache* cache) { void CompiledLightVm<Allocator, softAes>::setCache(randomx_cache* cache) {
mem.memory = cache->memory; mem.memory = cache->memory;
compiler.generateSuperscalarHash(cache->programs, cache->reciprocalCache); compiler.generateSuperscalarHash(cache->programs, cache->reciprocalCache);
//datasetBasePtr = ds.dataset.memory;
} }
template<class Allocator, bool softAes> template<class Allocator, bool softAes>
void CompiledLightVm<Allocator, softAes>::run(void* seed) { void CompiledLightVm<Allocator, softAes>::run(void* seed) {
VmBase<Allocator, softAes>::generateProgram(seed); VmBase<Allocator, softAes>::generateProgram(seed);
randomx_vm::initialize(); randomx_vm::initialize();
compiler.generateProgramLight(program, config); compiler.generateProgramLight(program, config, datasetOffset);
//mem.memory = datasetBasePtr + (datasetBase * CacheLineSize);
CompiledVm<Allocator, softAes>::execute(); CompiledVm<Allocator, softAes>::execute();
} }

1
src/vm_compiled_light.hpp
View File

@ -44,6 +44,7 @@ namespace randomx {
using CompiledVm<Allocator, softAes>::compiler; using CompiledVm<Allocator, softAes>::compiler;
using CompiledVm<Allocator, softAes>::program; using CompiledVm<Allocator, softAes>::program;
using CompiledVm<Allocator, softAes>::config; using CompiledVm<Allocator, softAes>::config;
using CompiledVm<Allocator, softAes>::datasetOffset;
}; };
using CompiledLightVmDefault = CompiledLightVm<AlignedAllocator<CacheLineSize>, true>; using CompiledLightVmDefault = CompiledLightVm<AlignedAllocator<CacheLineSize>, true>;

2
src/vm_interpreted.cpp
View File

@ -331,7 +331,7 @@ namespace randomx {
mem.mx ^= r[config.readReg2] ^ r[config.readReg3]; mem.mx ^= r[config.readReg2] ^ r[config.readReg3];
mem.mx &= CacheLineAlignMask; mem.mx &= CacheLineAlignMask;
datasetRead(mem.ma, r); datasetRead(datasetOffset + mem.ma, r);
std::swap(mem.mx, mem.ma); std::swap(mem.mx, mem.ma);
if (trace) { if (trace) {

2
src/vm_interpreted.hpp
View File

@ -57,6 +57,8 @@ namespace randomx {
using VmBase<Allocator, softAes>::program; using VmBase<Allocator, softAes>::program;
using VmBase<Allocator, softAes>::config; using VmBase<Allocator, softAes>::config;
using VmBase<Allocator, softAes>::reg; using VmBase<Allocator, softAes>::reg;
using VmBase<Allocator, softAes>::datasetBasePtr;
using VmBase<Allocator, softAes>::datasetOffset;
void* operator new(size_t size) { void* operator new(size_t size) {
void* ptr = AlignedAllocator<CacheLineSize>::allocMemory(size); void* ptr = AlignedAllocator<CacheLineSize>::allocMemory(size);
if (ptr == nullptr) if (ptr == nullptr)

1
src/vm_interpreted_light.cpp
View File

@ -25,7 +25,6 @@ namespace randomx {
template<class Allocator, bool softAes> template<class Allocator, bool softAes>
void InterpretedLightVm<Allocator, softAes>::setCache(randomx_cache* cache) { void InterpretedLightVm<Allocator, softAes>::setCache(randomx_cache* cache) {
mem.memory = cache->memory; mem.memory = cache->memory;
//datasetRange = (size - RANDOMX_DATASET_SIZE + CacheLineSize) / CacheLineSize;
cachePtr = cache; cachePtr = cache;
} }