RandomWOW/src/tests/benchmark.cpp

247 lines
8.1 KiB
C++
Raw Normal View History

2018-12-11 20:00:30 +00:00
/*
Copyright (c) 2019 tevador
2018-12-11 20:00:30 +00:00
This file is part of RandomX.
RandomX 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.
RandomX 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 RandomX. If not, see<http://www.gnu.org/licenses/>.
*/
2019-04-20 09:08:01 +00:00
2018-12-11 20:00:30 +00:00
#include <fstream>
#include <iostream>
#include <iomanip>
#include <exception>
#include <string>
2019-04-20 09:08:01 +00:00
#include <vector>
2018-12-19 20:54:44 +00:00
#include <thread>
#include <atomic>
#include "stopwatch.hpp"
#include "utility.hpp"
#include "../randomx.h"
#include "../blake2/endian.h"
2018-12-11 20:00:30 +00:00
2019-04-20 09:08:01 +00:00
const uint8_t blockTemplate_[] = {
2019-02-11 17:57:42 +00:00
0x07, 0x07, 0xf7, 0xa4, 0xf0, 0xd6, 0x05, 0xb3, 0x03, 0x26, 0x08, 0x16, 0xba, 0x3f, 0x10, 0x90, 0x2e, 0x1a, 0x14,
0x5a, 0xc5, 0xfa, 0xd3, 0xaa, 0x3a, 0xf6, 0xea, 0x44, 0xc1, 0x18, 0x69, 0xdc, 0x4f, 0x85, 0x3f, 0x00, 0x2b, 0x2e,
0xea, 0x00, 0x00, 0x00, 0x00, 0x77, 0xb2, 0x06, 0xa0, 0x2c, 0xa5, 0xb1, 0xd4, 0xce, 0x6b, 0xbf, 0xdf, 0x0a, 0xca,
0xc3, 0x8b, 0xde, 0xd3, 0x4d, 0x2d, 0xcd, 0xee, 0xf9, 0x5c, 0xd2, 0x0c, 0xef, 0xc1, 0x2f, 0x61, 0xd5, 0x61, 0x09
};
2018-12-11 20:00:30 +00:00
constexpr char hexmap[] = "0123456789abcdef";
void outputHex(std::ostream& os, const char* data, int length) {
for (int i = 0; i < length; ++i) {
os << hexmap[(data[i] & 0xF0) >> 4];
os << hexmap[data[i] & 0x0F];
}
}
2018-12-19 20:54:44 +00:00
class AtomicHash {
public:
AtomicHash() {
for (int i = 0; i < 4; ++i)
hash[i].store(0);
}
void xorWith(uint64_t update[4]) {
for (int i = 0; i < 4; ++i)
hash[i].fetch_xor(update[i]);
}
void print(std::ostream& os) {
for (int i = 0; i < 4; ++i)
print(hash[i], os);
os << std::endl;
}
private:
static void print(std::atomic<uint64_t>& hash, std::ostream& os) {
2018-12-19 20:54:44 +00:00
auto h = hash.load();
outputHex(std::cout, (char*)&h, sizeof(h));
}
std::atomic<uint64_t> hash[4];
};
2018-12-11 20:00:30 +00:00
void printUsage(const char* executable) {
std::cout << "Usage: " << executable << " [OPTIONS]" << std::endl;
std::cout << "Supported options:" << std::endl;
2019-02-11 17:57:42 +00:00
std::cout << " --help shows this message" << std::endl;
std::cout << " --mine mining mode: 2 GiB" << std::endl;
2019-03-28 15:40:53 +00:00
std::cout << " --verify verification mode: 256 MiB" << std::endl;
std::cout << " --jit x86-64 JIT compiled mode (default: interpreter)" << std::endl;
2019-02-11 17:57:42 +00:00
std::cout << " --largePages use large pages" << std::endl;
std::cout << " --softAes use software AES (default: x86 AES-NI)" << std::endl;
std::cout << " --threads T use T threads (default: 1)" << std::endl;
2019-02-19 21:47:45 +00:00
std::cout << " --init Q initialize dataset with Q threads (default: 1)" << std::endl;
2019-02-11 17:57:42 +00:00
std::cout << " --nonces N run N nonces (default: 1000)" << std::endl;
std::cout << " --seed S seed for cache initialization (default: 0)" << std::endl;
}
2019-04-20 09:08:01 +00:00
void mine(randomx_vm* vm, std::atomic<uint32_t>& atomicNonce, AtomicHash& result, uint32_t noncesCount, int thread) {
uint64_t hash[RANDOMX_HASH_SIZE / sizeof(uint64_t)];
2019-04-20 09:08:01 +00:00
uint8_t blockTemplate[sizeof(blockTemplate_)];
memcpy(blockTemplate, blockTemplate_, sizeof(blockTemplate));
void* noncePtr = blockTemplate + 39;
auto nonce = atomicNonce.fetch_add(1);
2018-12-19 20:54:44 +00:00
while (nonce < noncesCount) {
store32(noncePtr, nonce);
2019-04-20 09:08:01 +00:00
randomx_calculate_hash(vm, blockTemplate, sizeof(blockTemplate), &hash);
2018-12-19 20:54:44 +00:00
result.xorWith(hash);
nonce = atomicNonce.fetch_add(1);
}
2018-12-19 20:54:44 +00:00
}
2018-12-19 20:54:44 +00:00
int main(int argc, char** argv) {
bool softAes, miningMode, verificationMode, help, largePages, jit;
int noncesCount, threadCount, initThreadCount;
int32_t seed;
2018-12-19 20:54:44 +00:00
readOption("--softAes", argc, argv, softAes);
2019-02-11 17:57:42 +00:00
readOption("--mine", argc, argv, miningMode);
2019-02-19 21:47:45 +00:00
readOption("--verify", argc, argv, verificationMode);
2018-12-19 20:54:44 +00:00
readIntOption("--threads", argc, argv, threadCount, 1);
readIntOption("--nonces", argc, argv, noncesCount, 1000);
2019-02-19 21:47:45 +00:00
readIntOption("--init", argc, argv, initThreadCount, 1);
readIntOption("--seed", argc, argv, seed, 0);
readOption("--largePages", argc, argv, largePages);
2019-03-21 19:44:59 +00:00
readOption("--jit", argc, argv, jit);
2019-02-19 21:47:45 +00:00
readOption("--help", argc, argv, help);
2018-12-21 20:09:55 +00:00
std::cout << "RandomX benchmark" << std::endl;
2019-02-19 21:47:45 +00:00
if (help || (!miningMode && !verificationMode)) {
printUsage(argv[0]);
return 0;
}
std::atomic<uint32_t> atomicNonce(0);
2018-12-19 20:54:44 +00:00
AtomicHash result;
2019-04-20 09:08:01 +00:00
std::vector<randomx_vm*> vms;
2018-12-19 20:54:44 +00:00
std::vector<std::thread> threads;
2019-04-20 09:08:01 +00:00
randomx_dataset* dataset;
randomx_cache* cache;
randomx_flags flags = RANDOMX_FLAG_DEFAULT;
2019-04-20 09:08:01 +00:00
if (miningMode) {
flags = (randomx_flags)(flags | RANDOMX_FLAG_FULL_MEM);
std::cout << " - full memory mode (2 GiB)" << std::endl;
}
else {
std::cout << " - light memory mode (256 MiB)" << std::endl;
2019-04-20 09:08:01 +00:00
}
if (jit) {
flags = (randomx_flags)(flags | RANDOMX_FLAG_JIT);
std::cout << " - JIT compiled mode" << std::endl;
2019-04-20 09:08:01 +00:00
}
else {
std::cout << " - interpreted mode" << std::endl;
2019-04-20 09:08:01 +00:00
}
if (softAes) {
std::cout << " - software AES mode" << std::endl;
2019-04-20 09:08:01 +00:00
}
else {
flags = (randomx_flags)(flags | RANDOMX_FLAG_HARD_AES);
std::cout << " - hardware AES mode" << std::endl;
2019-04-20 09:08:01 +00:00
}
if (largePages) {
flags = (randomx_flags)(flags | RANDOMX_FLAG_LARGE_PAGES);
std::cout << " - large pages mode" << std::endl;
2019-04-20 09:08:01 +00:00
}
else {
std::cout << " - small pages mode" << std::endl;
2019-04-20 09:08:01 +00:00
}
2019-02-11 17:57:42 +00:00
2019-02-19 21:47:45 +00:00
std::cout << "Initializing";
if (miningMode)
2019-02-19 21:47:45 +00:00
std::cout << " (" << initThreadCount << " thread" << (initThreadCount > 1 ? "s)" : ")");
std::cout << " ..." << std::endl;
2018-12-11 20:00:30 +00:00
try {
2018-12-19 20:54:44 +00:00
Stopwatch sw(true);
2019-04-20 09:08:01 +00:00
cache = randomx_alloc_cache(flags);
if (cache == nullptr) {
std::cout << "ERROR: Cache allocation failed" << std::endl;
return 1;
}
randomx_init_cache(cache, &seed, sizeof(seed));
2019-04-20 09:08:01 +00:00
if (miningMode) {
dataset = randomx_alloc_dataset(flags);
if (dataset == nullptr) {
std::cout << "ERROR: Dataset allocation failed" << std::endl;
return 1;
}
2019-04-23 20:27:23 +00:00
uint32_t datasetItemCount = randomx_dataset_item_count();
2019-04-20 09:08:01 +00:00
if (initThreadCount > 1) {
2019-04-23 20:27:23 +00:00
auto perThread = datasetItemCount / initThreadCount;
auto remainder = datasetItemCount % initThreadCount;
uint32_t startItem = 0;
2019-04-20 09:08:01 +00:00
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;
}
2019-04-20 09:08:01 +00:00
for (unsigned i = 0; i < threads.size(); ++i) {
threads[i].join();
}
2018-12-23 14:12:54 +00:00
}
else {
2019-04-23 20:27:23 +00:00
randomx_init_dataset(dataset, cache, 0, datasetItemCount);
2018-12-19 20:54:44 +00:00
}
2019-04-20 09:08:01 +00:00
randomx_release_cache(cache);
2018-12-19 20:54:44 +00:00
threads.clear();
}
2019-04-20 09:08:01 +00:00
std::cout << "Memory initialized in " << sw.getElapsed() << " s" << std::endl;
2019-02-19 21:47:45 +00:00
std::cout << "Initializing " << threadCount << " virtual machine(s) ..." << std::endl;
2018-12-19 20:54:44 +00:00
for (int i = 0; i < threadCount; ++i) {
randomx_vm *vm = randomx_create_vm(flags, cache, dataset);
if (vm == nullptr) {
std::cout << "ERROR: Unsupported virtual machine options" << std::endl;
return 1;
}
2018-12-19 20:54:44 +00:00
vms.push_back(vm);
}
std::cout << "Running benchmark (" << noncesCount << " nonces) ..." << std::endl;
2018-12-11 20:00:30 +00:00
sw.restart();
2018-12-23 14:12:54 +00:00
if (threadCount > 1) {
for (unsigned i = 0; i < vms.size(); ++i) {
2019-02-13 21:46:32 +00:00
if (softAes)
threads.push_back(std::thread(&mine, vms[i], std::ref(atomicNonce), std::ref(result), noncesCount, i));
2019-02-13 21:46:32 +00:00
else
threads.push_back(std::thread(&mine, vms[i], std::ref(atomicNonce), std::ref(result), noncesCount, i));
2018-12-23 14:12:54 +00:00
}
for (unsigned i = 0; i < threads.size(); ++i) {
2018-12-23 14:12:54 +00:00
threads[i].join();
}
2018-12-19 20:54:44 +00:00
}
2018-12-23 14:12:54 +00:00
else {
mine(vms[0], std::ref(atomicNonce), std::ref(result), noncesCount, 0);
2018-12-11 20:00:30 +00:00
}
double elapsed = sw.getElapsed();
2018-12-19 11:38:10 +00:00
std::cout << "Calculated result: ";
2018-12-19 20:54:44 +00:00
result.print(std::cout);
if (noncesCount == 1000 && seed == 0)
std::cout << "Reference result: b69741719152625854031c2337ceae68c3030f2b9581a73acebaa69fc9b555fc" << std::endl;
2019-02-11 17:57:42 +00:00
if (!miningMode) {
std::cout << "Performance: " << 1000 * elapsed / noncesCount << " ms per hash" << std::endl;
2019-01-14 23:01:11 +00:00
}
else {
std::cout << "Performance: " << noncesCount / elapsed << " hashes per second" << std::endl;
2019-01-14 23:01:11 +00:00
}
2018-12-11 20:00:30 +00:00
}
catch (std::exception& e) {
std::cout << "ERROR: " << e.what() << std::endl;
return 1;
}
return 0;
}