493 lines
17 KiB
C++
493 lines
17 KiB
C++
|
/*
|
|||
|
|
Copyright (c) 2018-2019, tevador <tevador@gmail.com>
|
|||
|
|
|
|||
|
|
All rights reserved.
|
|||
|
|
|
|||
|
|
Redistribution and use in source and binary forms, with or without
|
|||
|
|
modification, are permitted provided that the following conditions are met:
|
|||
|
|
* Redistributions of source code must retain the above copyright
|
|||
|
|
notice, this list of conditions and the following disclaimer.
|
|||
|
|
* Redistributions in binary form must reproduce the above copyright
|
|||
|
|
notice, this list of conditions and the following disclaimer in the
|
|||
|
|
documentation and/or other materials provided with the distribution.
|
|||
|
|
* Neither the name of the copyright holder nor the
|
|||
|
|
names of its contributors may be used to endorse or promote products
|
|||
|
|
derived from this software without specific prior written permission.
|
|||
|
|
|
|||
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|||
|
|
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|||
|
|
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|||
|
|
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
|||
|
|
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|||
|
|
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|||
|
|
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|||
|
|
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|||
|
|
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|||
|
|
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
|
*/
|
|||
|
|
#include "mingw-std-threads-master/mingw.thread.h" //这个时因为使用#include <thread>会报错，mingw中thread不支持std，如果时其他编译器如vs等，就不需要；
|
|||
|
|
#include "randomx.h"
|
|||
|
|
#include "dataset.hpp"
|
|||
|
|
#include "vm_interpreted.hpp"
|
|||
|
|
#include "vm_interpreted_light.hpp"
|
|||
|
|
#include "vm_compiled.hpp"
|
|||
|
|
#include "vm_compiled_light.hpp"
|
|||
|
|
#include "blake2/blake2.h"
|
|||
|
|
#include "cpu.hpp"
|
|||
|
|
#include <cassert>
|
|||
|
|
#include <limits>
|
|||
|
|
|
|||
|
|
|
|||
|
|
randomx_flags randomx_get_flags() {
|
|||
|
|
randomx_flags flags = RANDOMX_HAVE_COMPILER ? RANDOMX_FLAG_JIT : RANDOMX_FLAG_DEFAULT;
|
|||
|
|
randomx::Cpu cpu;
|
|||
|
|
#ifdef __OpenBSD__
|
|||
|
|
if (flags == RANDOMX_FLAG_JIT) {
|
|||
|
|
flags |= RANDOMX_FLAG_SECURE;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
if (HAVE_AES && cpu.hasAes()) {
|
|||
|
|
flags |= RANDOMX_FLAG_HARD_AES;
|
|||
|
|
}
|
|||
|
|
if (randomx_argon2_impl_avx2() != nullptr && cpu.hasAvx2()) {
|
|||
|
|
flags |= RANDOMX_FLAG_ARGON2_AVX2;
|
|||
|
|
}
|
|||
|
|
if (randomx_argon2_impl_ssse3() != nullptr && cpu.hasSsse3()) {
|
|||
|
|
flags |= RANDOMX_FLAG_ARGON2_SSSE3;
|
|||
|
|
}
|
|||
|
|
return flags;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
randomx_cache *randomx_alloc_cache(randomx_flags flags) {
|
|||
|
|
randomx_cache *cache = nullptr;
|
|||
|
|
auto impl = randomx::selectArgonImpl(flags);
|
|||
|
|
if (impl == nullptr) {
|
|||
|
|
return cache;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
try {
|
|||
|
|
cache = new randomx_cache();
|
|||
|
|
cache->argonImpl = impl;
|
|||
|
|
switch ((int)(flags & (RANDOMX_FLAG_JIT | RANDOMX_FLAG_LARGE_PAGES))) {
|
|||
|
|
case RANDOMX_FLAG_DEFAULT:
|
|||
|
|
cache->dealloc = &randomx::deallocCache<randomx::DefaultAllocator>;
|
|||
|
|
cache->jit = nullptr;
|
|||
|
|
cache->initialize = &randomx::initCache;
|
|||
|
|
cache->datasetInit = &randomx::initDataset;
|
|||
|
|
cache->memory = (uint8_t*)randomx::DefaultAllocator::allocMemory(randomx::CacheSize); //randomx::CacheSize =256MB
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case RANDOMX_FLAG_JIT:
|
|||
|
|
cache->dealloc = &randomx::deallocCache<randomx::DefaultAllocator>;
|
|||
|
|
cache->jit = new randomx::JitCompiler();
|
|||
|
|
cache->initialize = &randomx::initCacheCompile;
|
|||
|
|
cache->datasetInit = cache->jit->getDatasetInitFunc();
|
|||
|
|
cache->memory = (uint8_t*)randomx::DefaultAllocator::allocMemory(randomx::CacheSize);
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case RANDOMX_FLAG_LARGE_PAGES:
|
|||
|
|
cache->dealloc = &randomx::deallocCache<randomx::LargePageAllocator>;
|
|||
|
|
cache->jit = nullptr;
|
|||
|
|
cache->initialize = &randomx::initCache;
|
|||
|
|
cache->datasetInit = &randomx::initDataset;
|
|||
|
|
cache->memory = (uint8_t*)randomx::LargePageAllocator::allocMemory(randomx::CacheSize);
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case RANDOMX_FLAG_JIT | RANDOMX_FLAG_LARGE_PAGES:
|
|||
|
|
cache->dealloc = &randomx::deallocCache<randomx::LargePageAllocator>;
|
|||
|
|
cache->jit = new randomx::JitCompiler();
|
|||
|
|
cache->initialize = &randomx::initCacheCompile;
|
|||
|
|
cache->datasetInit = cache->jit->getDatasetInitFunc();
|
|||
|
|
cache->memory = (uint8_t*)randomx::LargePageAllocator::allocMemory(randomx::CacheSize);
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
default:
|
|||
|
|
UNREACHABLE;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
catch (std::exception &ex) {
|
|||
|
|
if (cache != nullptr) {
|
|||
|
|
randomx_release_cache(cache);
|
|||
|
|
cache = nullptr;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return cache;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void randomx_init_cache(randomx_cache *cache, const void *key, size_t keySize) {
|
|||
|
|
assert(cache != nullptr);
|
|||
|
|
assert(keySize == 0 || key != nullptr);
|
|||
|
|
|
|||
|
|
cache->initialize(cache, key, keySize);
|
|||
|
|
|
|||
|
|
//std::string cacheKey;
|
|||
|
|
//cacheKey.assign((const char *)key, keySize); //将字符串key中keysize个长度的字符赋值给cacheKey;
|
|||
|
|
//if (cache->cacheKey != cacheKey || !cache->isInitialized()) {
|
|||
|
|
// cache->initialize(cache, key, keySize);
|
|||
|
|
// cache->cacheKey = cacheKey;
|
|||
|
|
//}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void randomx_release_cache(randomx_cache* cache) {
|
|||
|
|
assert(cache != nullptr);
|
|||
|
|
if (cache->memory != nullptr) {
|
|||
|
|
cache->dealloc(cache);
|
|||
|
|
}
|
|||
|
|
delete cache;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
randomx_dataset *randomx_alloc_dataset(randomx_flags flags) {
|
|||
|
|
|
|||
|
|
//fail on 32-bit systems if DatasetSize is >= 4 GiB
|
|||
|
|
if (randomx::DatasetSize > std::numeric_limits<size_t>::max()) {
|
|||
|
|
return nullptr;
|
|||
|
|
}
|
|||
|
|
//printf("xxxxx\n");
|
|||
|
|
randomx_dataset *dataset = nullptr;
|
|||
|
|
|
|||
|
|
//try {
|
|||
|
|
dataset = new randomx_dataset();
|
|||
|
|
if (flags & RANDOMX_FLAG_LARGE_PAGES) {
|
|||
|
|
dataset->dealloc = &randomx::deallocDataset<randomx::LargePageAllocator>;
|
|||
|
|
dataset->memory = (uint8_t*)randomx::LargePageAllocator::allocMemory(randomx::DatasetSize);
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
dataset->dealloc = &randomx::deallocDataset<randomx::DefaultAllocator>;
|
|||
|
|
dataset->memory = (uint8_t*)randomx::DefaultAllocator::allocMemory(randomx::DatasetSize);
|
|||
|
|
}
|
|||
|
|
//}
|
|||
|
|
//catch (std::exception &ex) {
|
|||
|
|
// if (dataset != nullptr) {
|
|||
|
|
// randomx_release_dataset(dataset);
|
|||
|
|
// dataset = nullptr;
|
|||
|
|
// }
|
|||
|
|
//}
|
|||
|
|
|
|||
|
|
return dataset;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
constexpr unsigned long DatasetItemCount = randomx::DatasetSize / RANDOMX_DATASET_ITEM_SIZE;
|
|||
|
|
|
|||
|
|
unsigned long randomx_dataset_item_count() {
|
|||
|
|
return DatasetItemCount;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void randomx_init_dataset(randomx_dataset *dataset, randomx_cache *cache, unsigned long startItem, unsigned long itemCount) {
|
|||
|
|
assert(dataset != nullptr);
|
|||
|
|
assert(cache != nullptr);
|
|||
|
|
assert(startItem < DatasetItemCount && itemCount <= DatasetItemCount);
|
|||
|
|
assert(startItem + itemCount <= DatasetItemCount);
|
|||
|
|
cache->datasetInit(cache, dataset->memory + startItem * randomx::CacheLineSize, startItem, startItem + itemCount);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void *randomx_get_dataset_memory(randomx_dataset *dataset) {
|
|||
|
|
assert(dataset != nullptr);
|
|||
|
|
return dataset->memory;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void randomx_release_dataset(randomx_dataset *dataset) {
|
|||
|
|
assert(dataset != nullptr);
|
|||
|
|
dataset->dealloc(dataset);
|
|||
|
|
delete dataset;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
randomx_vm *randomx_create_vm(randomx_flags flags, randomx_cache *cache, randomx_dataset *dataset) {
|
|||
|
|
assert(cache != nullptr || (flags & RANDOMX_FLAG_FULL_MEM));
|
|||
|
|
assert(cache == nullptr || cache->isInitialized());
|
|||
|
|
assert(dataset != nullptr || !(flags & RANDOMX_FLAG_FULL_MEM));
|
|||
|
|
|
|||
|
|
randomx_vm *vm = nullptr;
|
|||
|
|
|
|||
|
|
try {
|
|||
|
|
switch ((int)(flags & (RANDOMX_FLAG_FULL_MEM | RANDOMX_FLAG_JIT | RANDOMX_FLAG_HARD_AES | RANDOMX_FLAG_LARGE_PAGES))) {
|
|||
|
|
case RANDOMX_FLAG_DEFAULT:
|
|||
|
|
vm = new randomx::InterpretedLightVmDefault();
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case RANDOMX_FLAG_FULL_MEM:
|
|||
|
|
vm = new randomx::InterpretedVmDefault();
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case RANDOMX_FLAG_JIT:
|
|||
|
|
if (flags & RANDOMX_FLAG_SECURE) {
|
|||
|
|
vm = new randomx::CompiledLightVmDefaultSecure();
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
vm = new randomx::CompiledLightVmDefault();
|
|||
|
|
}
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case RANDOMX_FLAG_FULL_MEM | RANDOMX_FLAG_JIT:
|
|||
|
|
if (flags & RANDOMX_FLAG_SECURE) {
|
|||
|
|
vm = new randomx::CompiledVmDefaultSecure();
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
vm = new randomx::CompiledVmDefault();
|
|||
|
|
}
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case RANDOMX_FLAG_HARD_AES:
|
|||
|
|
vm = new randomx::InterpretedLightVmHardAes();
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case RANDOMX_FLAG_FULL_MEM | RANDOMX_FLAG_HARD_AES:
|
|||
|
|
vm = new randomx::InterpretedVmHardAes();
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case RANDOMX_FLAG_JIT | RANDOMX_FLAG_HARD_AES:
|
|||
|
|
if (flags & RANDOMX_FLAG_SECURE) {
|
|||
|
|
vm = new randomx::CompiledLightVmHardAesSecure();
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
vm = new randomx::CompiledLightVmHardAes();
|
|||
|
|
}
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case RANDOMX_FLAG_FULL_MEM | RANDOMX_FLAG_JIT | RANDOMX_FLAG_HARD_AES:
|
|||
|
|
if (flags & RANDOMX_FLAG_SECURE) {
|
|||
|
|
vm = new randomx::CompiledVmHardAesSecure();
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
vm = new randomx::CompiledVmHardAes();
|
|||
|
|
}
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case RANDOMX_FLAG_LARGE_PAGES:
|
|||
|
|
vm = new randomx::InterpretedLightVmLargePage();
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case RANDOMX_FLAG_FULL_MEM | RANDOMX_FLAG_LARGE_PAGES:
|
|||
|
|
vm = new randomx::InterpretedVmLargePage();
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case RANDOMX_FLAG_JIT | RANDOMX_FLAG_LARGE_PAGES:
|
|||
|
|
if (flags & RANDOMX_FLAG_SECURE) {
|
|||
|
|
vm = new randomx::CompiledLightVmLargePageSecure();
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
vm = new randomx::CompiledLightVmLargePage();
|
|||
|
|
}
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case RANDOMX_FLAG_FULL_MEM | RANDOMX_FLAG_JIT | RANDOMX_FLAG_LARGE_PAGES:
|
|||
|
|
if (flags & RANDOMX_FLAG_SECURE) {
|
|||
|
|
vm = new randomx::CompiledVmLargePageSecure();
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
vm = new randomx::CompiledVmLargePage();
|
|||
|
|
}
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case RANDOMX_FLAG_HARD_AES | RANDOMX_FLAG_LARGE_PAGES:
|
|||
|
|
vm = new randomx::InterpretedLightVmLargePageHardAes();
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case RANDOMX_FLAG_FULL_MEM | RANDOMX_FLAG_HARD_AES | RANDOMX_FLAG_LARGE_PAGES:
|
|||
|
|
vm = new randomx::InterpretedVmLargePageHardAes();
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case RANDOMX_FLAG_JIT | RANDOMX_FLAG_HARD_AES | RANDOMX_FLAG_LARGE_PAGES:
|
|||
|
|
if (flags & RANDOMX_FLAG_SECURE) {
|
|||
|
|
vm = new randomx::CompiledLightVmLargePageHardAesSecure();
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
vm = new randomx::CompiledLightVmLargePageHardAes();
|
|||
|
|
}
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case RANDOMX_FLAG_FULL_MEM | RANDOMX_FLAG_JIT | RANDOMX_FLAG_HARD_AES | RANDOMX_FLAG_LARGE_PAGES:
|
|||
|
|
if (flags & RANDOMX_FLAG_SECURE) {
|
|||
|
|
vm = new randomx::CompiledVmLargePageHardAesSecure();
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
vm = new randomx::CompiledVmLargePageHardAes();
|
|||
|
|
}
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
default:
|
|||
|
|
UNREACHABLE;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if(cache != nullptr) {
|
|||
|
|
// printf("cachedddddddddddd\n"); yes
|
|||
|
|
vm->setCache(cache);
|
|||
|
|
vm->cacheKey = cache->cacheKey;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if(dataset != nullptr){
|
|||
|
|
// printf("datasetdddddddddddd\n"); no
|
|||
|
|
vm->setDataset(dataset);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
vm->allocate(); //allocate the scratchpad
|
|||
|
|
}
|
|||
|
|
catch (std::exception &ex) {
|
|||
|
|
delete vm;
|
|||
|
|
vm = nullptr;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return vm;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void randomx_vm_set_cache(randomx_vm *machine, randomx_cache* cache) {
|
|||
|
|
assert(machine != nullptr);
|
|||
|
|
assert(cache != nullptr && cache->isInitialized());
|
|||
|
|
if (machine->cacheKey != cache->cacheKey) {
|
|||
|
|
machine->setCache(cache);
|
|||
|
|
machine->cacheKey = cache->cacheKey;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void randomx_vm_set_dataset(randomx_vm *machine, randomx_dataset *dataset) {
|
|||
|
|
assert(machine != nullptr);
|
|||
|
|
assert(dataset != nullptr);
|
|||
|
|
machine->setDataset(dataset);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void randomx_destroy_vm(randomx_vm *machine) {
|
|||
|
|
assert(machine != nullptr);
|
|||
|
|
delete machine;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void randomx_calculate_hash(randomx_vm *machine, const void *input, size_t inputSize, void *output) {
|
|||
|
|
assert(machine != nullptr);
|
|||
|
|
assert(inputSize == 0 || input != nullptr);
|
|||
|
|
assert(output != nullptr);
|
|||
|
|
alignas(16) uint64_t tempHash[8];
|
|||
|
|
int blakeResult = blake2b(tempHash, sizeof(tempHash), input, inputSize, nullptr, 0);
|
|||
|
|
assert(blakeResult == 0);
|
|||
|
|
machine->initScratchpad(&tempHash);
|
|||
|
|
machine->resetRoundingMode();
|
|||
|
|
for (int chain = 0; chain < RANDOMX_PROGRAM_COUNT - 1; ++chain) { //RANDOMX_PROGRAM_COUNT =8
|
|||
|
|
machine->run(&tempHash);
|
|||
|
|
blakeResult = blake2b(tempHash, sizeof(tempHash), machine->getRegisterFile(), sizeof(randomx::RegisterFile), nullptr, 0);
|
|||
|
|
assert(blakeResult == 0);
|
|||
|
|
}
|
|||
|
|
machine->run(&tempHash);
|
|||
|
|
machine->getFinalResult(output, RANDOMX_HASH_SIZE);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
int main(int argc, char** argv) {
|
|||
|
|
|
|||
|
|
const uint8_t myKey[] ={ 0x67,0x0f,0x0b,0x99,0x1d,0xc3,0xfe,0x80,0x56,0x04,0xea,0xc3,0x79,0x35,0x1d,0x9a,0xb5,0x21,0xef,0xac,0x60,0x95,0xf2,0x6b,0xca,0xa3,0xa8,0x56,0x83,0x89,0x77,0x99};
|
|||
|
|
|
|||
|
|
const uint8_t myInput[] = { 0x0e,0x0e,0xe4,0xf3,0xf4,0xff,0x05,0x81,0xd4,0x1a,0x87,0xb3,0xa3,0xd7,0xb6,0x40,0x24,0x8d,0x9f,0x34,0x86,0x07,0xe9,0x67,0x55,0x5c,0xce,0x2f,0x40,0xe6,0x5e,0x5e,0x40,0x45,0x46,0x56,0x9e,0xb3,0xe6,
|
|||
|
|
//0xee,0x85,0x00,0x00,
|
|||
|
|
0xe6,0x23,0x00,0x00,
|
|||
|
|
0xcb,0x84,0x81,0x0b,0xc0,0x28,0xa5,0x76,0xec,0xd2,0x0b,0xf9,0xee,0xee,0x43,0x78,0x9c,0x3d,0x55,0xe5,0x54,0xe3,0x05,0xb3,0x46,0x02,0x09,0x64,0x43,0x21,0xd2,0x9e,0x28};
|
|||
|
|
|
|||
|
|
uint8_t hash[RANDOMX_HASH_SIZE];
|
|||
|
|
int initThreadCount =16;
|
|||
|
|
randomx_cache* cache = randomx_alloc_cache(RANDOMX_FLAG_DEFAULT);
|
|||
|
|
|
|||
|
|
randomx_init_cache(cache, myKey, sizeof myKey);
|
|||
|
|
|
|||
|
|
uint32_t datasetItemCount = randomx_dataset_item_count();
|
|||
|
|
|
|||
|
|
printf("datasetItemCount=%d\n", datasetItemCount);
|
|||
|
|
|
|||
|
|
randomx_dataset* dataset = randomx_alloc_dataset(RANDOMX_FLAG_DEFAULT);
|
|||
|
|
|
|||
|
|
std::vector<std::thread> threads;
|
|||
|
|
auto perThread = datasetItemCount / initThreadCount;
|
|||
|
|
auto remainder = datasetItemCount % initThreadCount;
|
|||
|
|
uint32_t startItem = 0;
|
|||
|
|
for (int i = 0; i < initThreadCount; ++i) {
|
|||
|
|
auto count = perThread + (i == initThreadCount - 1 ? remainder : 0);
|
|||
|
|
threads.push_back(std::thread(&randomx_init_dataset, dataset, cache, startItem, count));
|
|||
|
|
startItem += count;
|
|||
|
|
}
|
|||
|
|
for (unsigned i = 0; i < threads.size(); ++i) {
|
|||
|
|
threads[i].join();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
randomx_release_cache(cache);
|
|||
|
|
|
|||
|
|
randomx_vm* vm = randomx_create_vm(RANDOMX_FLAG_FULL_MEM,nullptr, dataset);
|
|||
|
|
|
|||
|
|
randomx_calculate_hash(vm, &myInput, sizeof myInput, hash);
|
|||
|
|
|
|||
|
|
randomx_destroy_vm(vm);
|
|||
|
|
|
|||
|
|
randomx_release_dataset(dataset);
|
|||
|
|
|
|||
|
|
for (unsigned i = 0; i < RANDOMX_HASH_SIZE; ++i)
|
|||
|
|
printf("%02x", hash[i] & 0xff);
|
|||
|
|
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
//8a48e5f9db45ab79d98574c4d81954fe6ac63842214aff73c244b26330b7c9
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
int main() {
|
|||
|
|
|
|||
|
|
const uint8_t myKey[] ={ 0x67,0x0f,0x0b,0x99,0x1d,0xc3,0xfe,0x80,0x56,0x04,0xea,0xc3,0x79,0x35,0x1d,0x9a,0xb5,0x21,0xef,0xac,0x60,0x95,0xf2,0x6b,0xca,0xa3,0xa8,0x56,0x83,0x89,0x77,0x99};
|
|||
|
|
|
|||
|
|
const uint8_t myInput[] = { 0x0e,0x0e,0xe4,0xf3,0xf4,0xff,0x05,0x81,0xd4,0x1a,0x87,0xb3,0xa3,0xd7,0xb6,0x40,0x24,0x8d,0x9f,0x34,0x86,0x07,0xe9,0x67,0x55,0x5c,0xce,0x2f,0x40,0xe6,0x5e,0x5e,0x40,0x45,0x46,0x56,0x9e,0xb3,0xe6,
|
|||
|
|
//0xee,0x85,0x00,0x00,
|
|||
|
|
0xe6,0x23,0x00,0x00,
|
|||
|
|
0xcb,0x84,0x81,0x0b,0xc0,0x28,0xa5,0x76,0xec,0xd2,0x0b,0xf9,0xee,0xee,0x43,0x78,0x9c,0x3d,0x55,0xe5,0x54,0xe3,0x05,0xb3,0x46,0x02,0x09,0x64,0x43,0x21,0xd2,0x9e,0x28};
|
|||
|
|
|
|||
|
|
char hash[RANDOMX_HASH_SIZE];
|
|||
|
|
|
|||
|
|
//randomx_flags flags = randomx_get_flags();
|
|||
|
|
randomx_flags flags = RANDOMX_FLAG_DEFAULT;
|
|||
|
|
randomx_cache *myCache = randomx_alloc_cache(flags);
|
|||
|
|
|
|||
|
|
randomx_init_cache(myCache, &myKey, sizeof myKey);
|
|||
|
|
|
|||
|
|
randomx_vm *myMachine = randomx_create_vm(flags, myCache, NULL);
|
|||
|
|
|
|||
|
|
randomx_calculate_hash(myMachine, &myInput, sizeof myInput, hash);
|
|||
|
|
|
|||
|
|
randomx_destroy_vm(myMachine);
|
|||
|
|
randomx_release_cache(myCache);
|
|||
|
|
|
|||
|
|
for (unsigned i = 0; i < RANDOMX_HASH_SIZE; ++i)
|
|||
|
|
printf("%02x", hash[i] & 0xff);
|
|||
|
|
|
|||
|
|
printf("\n");
|
|||
|
|
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
|
|||
|
|
randomx_cache* cache;
|
|||
|
|
randomx_vm* vm = nullptr;
|
|||
|
|
|
|||
|
|
int main(){
|
|||
|
|
|
|||
|
|
const uint8_t myKey[] ={ 0x67,0x0f,0x0b,0x99,0x1d,0xc3,0xfe,0x80,0x56,0x04,0xea,0xc3,0x79,0x35,0x1d,0x9a,0xb5,0x21,0xef,0xac,0x60,0x95,0xf2,0x6b,0xca,0xa3,0xa8,0x56,0x83,0x89,0x77,0x99};
|
|||
|
|
|
|||
|
|
const uint8_t myInput[] = { 0x0e,0x0e,0xe4,0xf3,0xf4,0xff,0x05,0x81,0xd4,0x1a,0x87,0xb3,0xa3,0xd7,0xb6,0x40,0x24,0x8d,0x9f,0x34,0x86,0x07,0xe9,0x67,0x55,0x5c,0xce,0x2f,0x40,0xe6,0x5e,0x5e,0x40,0x45,0x46,0x56,0x9e,0xb3,0xe6,
|
|||
|
|
0xe6,0x23,0x00,0x00,
|
|||
|
|
0xcb,0x84,0x81,0x0b,0xc0,0x28,0xa5,0x76,0xec,0xd2,0x0b,0xf9,0xee,0xee,0x43,0x78,0x9c,0x3d,0x55,0xe5,0x54,0xe3,0x05,0xb3,0x46,0x02,0x09,0x64,0x43,0x21,0xd2,0x9e,0x28};
|
|||
|
|
|
|||
|
|
|
|||
|
|
// const uint8_t myKey[] ={146, 6, 71, 248, 241, 11, 139, 72, 70, 73, 173, 248, 53, 153, 197, 184, 107, 186, 19, 126, 126, 178, 46, 149, 221, 135, 57, 217, 133, 40, 246, 119};
|
|||
|
|
// const uint8_t myInput[] = {0, 0, 0, 14, 246, 237, 44, 156, 4, 131, 10, 137, 157, 56, 143, 188, 94, 194, 80, 172, 219, 123, 75, 112, 250, 36, 34, 195, 214, 232, 2, 195, 72, 210, 201, 0, 0, 0, 0, 0, 128, 7, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
|
|||
|
|
|
|||
|
|
uint8_t hash[RANDOMX_HASH_SIZE];
|
|||
|
|
cache = randomx_alloc_cache(RANDOMX_FLAG_DEFAULT);
|
|||
|
|
randomx_init_cache(cache, myKey, sizeof(myKey));
|
|||
|
|
|
|||
|
|
vm = randomx_create_vm(RANDOMX_FLAG_DEFAULT, cache, nullptr);
|
|||
|
|
// randomx_vm_set_cache(vm, cache);
|
|||
|
|
|
|||
|
|
randomx_calculate_hash(vm, myInput, sizeof(myInput), hash);
|
|||
|
|
for (unsigned i = 0; i < RANDOMX_HASH_SIZE; ++i)
|
|||
|
|
// printf("%02d ", hash[i] & 0xff);
|
|||
|
|
printf("%02x", hash[i] & 0xff);
|
|||
|
|
|
|||
|
|
|
|||
|
|
//assert(equalsHex(hash, "1a7151b1367507ded1e9af0b97da8ae23ec84e9f352eb731eab8f0f060710300"));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
//g++ aes_hash.cpp allocator.cpp argon2_avx2.c argon2_core.c argon2_ref.c argon2_ssse3.c assembly_generator_x86.cpp blake2_generator.cpp bytecode_machine.cpp cpu.cpp dataset.cpp instruction.cpp instructions_portable.cpp randomx.cpp reciprocal.c soft_aes.cpp superscalar.cpp virtual_machine.cpp virtual_memory.cpp vm_compiled.cpp vm_compiled_light.cpp vm_interpreted.cpp vm_interpreted_light.cpp ./blake2/blake2b.c jit_compiler_x86.cpp jit_compiler_x86_static.S
|