Page MenuHomePhabricator
Differential D9226 Diff 27698 src/bench/crypto_hash.cpp

Changeset View

Standalone View

View Options

src/bench/crypto_hash.cpp

Show All 12 Lines
#include <random.h> #include <random.h>
#include <uint256.h> #include <uint256.h>
#include <string> #include <string>
/* Number of bytes to hash per iteration */ /* Number of bytes to hash per iteration */
static const uint64_t BUFFER_SIZE = 1000 * 1000; static const uint64_t BUFFER_SIZE = 1000 * 1000;
static void RIPEMD160(benchmark::State &state) { static void RIPEMD160(benchmark::Bench &bench) {
uint8_t hash[CRIPEMD160::OUTPUT_SIZE]; uint8_t hash[CRIPEMD160::OUTPUT_SIZE];
std::vector<uint8_t> in(BUFFER_SIZE, 0); std::vector<uint8_t> in(BUFFER_SIZE, 0);
while (state.KeepRunning()) { bench.batch(in.size()).unit("byte").run(
CRIPEMD160().Write(in.data(), in.size()).Finalize(hash); [&] { CRIPEMD160().Write(in.data(), in.size()).Finalize(hash); });
}
} }
static void SHA1(benchmark::State &state) { static void SHA1(benchmark::Bench &bench) {
uint8_t hash[CSHA1::OUTPUT_SIZE]; uint8_t hash[CSHA1::OUTPUT_SIZE];
std::vector<uint8_t> in(BUFFER_SIZE, 0); std::vector<uint8_t> in(BUFFER_SIZE, 0);
while (state.KeepRunning()) { bench.batch(in.size()).unit("byte").run(
CSHA1().Write(in.data(), in.size()).Finalize(hash); [&] { CSHA1().Write(in.data(), in.size()).Finalize(hash); });
}
} }
static void SHA256(benchmark::State &state) { static void SHA256(benchmark::Bench &bench) {
uint8_t hash[CSHA256::OUTPUT_SIZE]; uint8_t hash[CSHA256::OUTPUT_SIZE];
std::vector<uint8_t> in(BUFFER_SIZE, 0); std::vector<uint8_t> in(BUFFER_SIZE, 0);
while (state.KeepRunning()) { bench.batch(in.size()).unit("byte").run(
CSHA256().Write(in.data(), in.size()).Finalize(hash); [&] { CSHA256().Write(in.data(), in.size()).Finalize(hash); });
}
} }
static void SHA3_256_1M(benchmark::State &state) { static void SHA3_256_1M(benchmark::Bench &bench) {
uint8_t hash[SHA3_256::OUTPUT_SIZE]; uint8_t hash[SHA3_256::OUTPUT_SIZE];
std::vector<uint8_t> in(BUFFER_SIZE, 0); std::vector<uint8_t> in(BUFFER_SIZE, 0);
while (state.KeepRunning()) { bench.batch(in.size()).unit("byte").run(
SHA3_256().Write(in).Finalize(hash); [&] { SHA3_256().Write(in).Finalize(hash); });
}
} }
static void SHA256_32b(benchmark::State &state) { static void SHA256_32b(benchmark::Bench &bench) {
std::vector<uint8_t> in(32, 0); std::vector<uint8_t> in(32, 0);
while (state.KeepRunning()) { bench.batch(in.size()).unit("byte").run(
CSHA256().Write(in.data(), in.size()).Finalize(in.data()); [&] { CSHA256().Write(in.data(), in.size()).Finalize(in.data()); });
}
} }
static void SHA256D64_1024(benchmark::State &state) { static void SHA256D64_1024(benchmark::Bench &bench) {
std::vector<uint8_t> in(64 * 1024, 0); std::vector<uint8_t> in(64 * 1024, 0);
while (state.KeepRunning()) { bench.batch(in.size()).unit("byte").run(
SHA256D64(in.data(), in.data(), 1024); [&] { SHA256D64(in.data(), in.data(), 1024); });
}
} }
static void SHA512(benchmark::State &state) { static void SHA512(benchmark::Bench &bench) {
uint8_t hash[CSHA512::OUTPUT_SIZE]; uint8_t hash[CSHA512::OUTPUT_SIZE];
std::vector<uint8_t> in(BUFFER_SIZE, 0); std::vector<uint8_t> in(BUFFER_SIZE, 0);
while (state.KeepRunning()) { bench.batch(in.size()).unit("byte").run(
CSHA512().Write(in.data(), in.size()).Finalize(hash); [&] { CSHA512().Write(in.data(), in.size()).Finalize(hash); });
}
} }
static void SipHash_32b(benchmark::State &state) { static void SipHash_32b(benchmark::Bench &bench) {
uint256 x; uint256 x;
uint64_t k1 = 0; uint64_t k1 = 0;
while (state.KeepRunning()) { bench.run([&] {
uint64_t hash64 = SipHashUint256(0, ++k1, x); uint64_t hash64 = SipHashUint256(0, ++k1, x);
std::memcpy(x.begin(), &hash64, sizeof(hash64)); std::memcpy(x.begin(), &hash64, sizeof(hash64));
} });
} }
static void FastRandom_32bit(benchmark::State &state) { static void FastRandom_32bit(benchmark::Bench &bench) {
FastRandomContext rng(true); FastRandomContext rng(true);
while (state.KeepRunning()) { bench.run([&] { rng.rand32(); });
rng.rand32();
}
} }
static void FastRandom_1bit(benchmark::State &state) { static void FastRandom_1bit(benchmark::Bench &bench) {
FastRandomContext rng(true); FastRandomContext rng(true);
while (state.KeepRunning()) { bench.run([&] { rng.randbool(); });
rng.randbool();
}
} }
BENCHMARK(RIPEMD160, 440); BENCHMARK(RIPEMD160);
BENCHMARK(SHA1, 570); BENCHMARK(SHA1);
BENCHMARK(SHA256, 340); BENCHMARK(SHA256);
BENCHMARK(SHA512, 330); BENCHMARK(SHA512);
BENCHMARK(SHA3_256_1M, 300); BENCHMARK(SHA3_256_1M);
BENCHMARK(SHA256_32b, 4700 * 1000); BENCHMARK(SHA256_32b);
BENCHMARK(SipHash_32b, 40 * 1000 * 1000); BENCHMARK(SipHash_32b);
BENCHMARK(SHA256D64_1024, 7400); BENCHMARK(SHA256D64_1024);
BENCHMARK(FastRandom_32bit, 110 * 1000 * 1000); BENCHMARK(FastRandom_32bit);
BENCHMARK(FastRandom_1bit, 440 * 1000 * 1000); BENCHMARK(FastRandom_1bit);