phantom/bitcoin
1
0
Fork 0
mirror of https://github.com/bitcoin/bitcoin.git synced 2025-04-29 14:59:39 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

bench: Add COutPoint and SaltedOutpointHasher benchmarks

Browse source 
This commit introduces new benchmarks to measure the performance of various operations using
SaltedOutpointHasher, including hash computation, set operations, and set creation.

These benchmarks are intended to provide insights about coin caching performance (e.g. during IBD).

> cmake -B build -DBUILD_BENCH=ON -DCMAKE_BUILD_TYPE=Release && cmake --build build -j$(nproc) && build/src/bench/bench_bitcoin -filter='SaltedOutpointHasherBench.*' -min-time=10000

> C++ compiler .......................... AppleClang 16.0.0.16000026

|               ns/op |                op/s |    err% |     total | benchmark
|--------------------:|--------------------:|--------:|----------:|:----------
|               58.60 |       17,065,922.04 |    0.3% |     11.02 | `SaltedOutpointHasherBench_create_set`
|               11.97 |       83,576,684.83 |    0.1% |     11.01 | `SaltedOutpointHasherBench_hash`
|               14.50 |       68,985,850.12 |    0.3% |     10.96 | `SaltedOutpointHasherBench_match`
|               13.90 |       71,942,033.47 |    0.4% |     11.03 | `SaltedOutpointHasherBench_mismatch`

> C++ compiler .......................... GNU 13.3.0

|               ns/op |                op/s |    err% |          ins/op |          cyc/op |    IPC |         bra/op |   miss% |     total | benchmark
|--------------------:|--------------------:|--------:|----------------:|----------------:|-------:|---------------:|--------:|----------:|:----------
|              136.76 |        7,312,133.16 |    0.0% |        1,086.67 |          491.12 |  2.213 |         119.54 |    1.1% |     11.01 | `SaltedOutpointHasherBench_create_set`
|               23.82 |       41,978,882.62 |    0.0% |          252.01 |           85.57 |  2.945 |           4.00 |    0.0% |     11.00 | `SaltedOutpointHasherBench_hash`
|               60.42 |       16,549,695.42 |    0.1% |          460.51 |          217.04 |  2.122 |          21.00 |    1.4% |     10.99 | `SaltedOutpointHasherBench_match`
|               78.66 |       12,713,595.35 |    0.1% |          555.59 |          282.52 |  1.967 |          20.19 |    2.2% |     10.74 | `SaltedOutpointHasherBench_mismatch`
This commit is contained in:
Lőrinc 2024-06-21 18:00:14 +02:00
parent c5e866b190
commit c497ca6e91
1 changed files with 99 additions and 2 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

101
src/bench/crypto_hash.cpp
View file

@ -2,7 +2,6 @@
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include <bench/bench.h>
#include <crypto/muhash.h>
#include <crypto/ripemd160.h>
@ -12,9 +11,11 @@
#include <crypto/sha512.h>
#include <crypto/siphash.h>
#include <random.h>
#include <span.h>
#include <tinyformat.h>
#include <uint256.h>
#include <primitives/transaction.h>
#include <util/hasher.h>
#include <unordered_set>
#include <cstdint>
#include <vector>
@ -205,6 +206,98 @@ static void SipHash_32b(benchmark::Bench& bench)
});
}
static void SaltedOutpointHasherBench_hash(benchmark::Bench& bench)
{
FastRandomContext rng{/*fDeterministic=*/true};
constexpr size_t size{1000};
std::vector<COutPoint> outpoints(size);
for (auto& outpoint : outpoints) {
outpoint = {Txid::FromUint256(rng.rand256()), rng.rand32()};
}
const SaltedOutpointHasher hasher;
bench.batch(size).run([&] {
size_t result{0};
for (const auto& outpoint : outpoints) {
result ^= hasher(outpoint);
}
ankerl::nanobench::doNotOptimizeAway(result);
});
}
static void SaltedOutpointHasherBench_match(benchmark::Bench& bench)
{
FastRandomContext rng{/*fDeterministic=*/true};
constexpr size_t size{1000};
std::unordered_set<COutPoint, SaltedOutpointHasher> values;
std::vector<COutPoint> value_vector;
values.reserve(size);
value_vector.reserve(size);
for (size_t i{0}; i < size; ++i) {
COutPoint outpoint{Txid::FromUint256(rng.rand256()), rng.rand32()};
values.emplace(outpoint);
value_vector.push_back(outpoint);
assert(values.contains(outpoint));
}
bench.batch(size).run([&] {
bool result{true};
for (const auto& outpoint : value_vector) {
result ^= values.contains(outpoint);
}
ankerl::nanobench::doNotOptimizeAway(result);
});
}
static void SaltedOutpointHasherBench_mismatch(benchmark::Bench& bench)
{
FastRandomContext rng{/*fDeterministic=*/true};
constexpr size_t size{1000};
std::unordered_set<COutPoint, SaltedOutpointHasher> values;
std::vector<COutPoint> missing_value_vector;
values.reserve(size);
missing_value_vector.reserve(size);
for (size_t i{0}; i < size; ++i) {
values.emplace(Txid::FromUint256(rng.rand256()), rng.rand32());
COutPoint missing_outpoint{Txid::FromUint256(rng.rand256()), rng.rand32()};
missing_value_vector.push_back(missing_outpoint);
assert(!values.contains(missing_outpoint));
}
bench.batch(size).run([&] {
bool result{false};
for (const auto& outpoint : missing_value_vector) {
result ^= values.contains(outpoint);
}
ankerl::nanobench::doNotOptimizeAway(result);
});
}
static void SaltedOutpointHasherBench_create_set(benchmark::Bench& bench)
{
FastRandomContext rng{/*fDeterministic=*/true};
constexpr size_t size{1000};
std::vector<COutPoint> outpoints(size);
for (auto& outpoint : outpoints) {
outpoint = {Txid::FromUint256(rng.rand256()), rng.rand32()};
}
bench.batch(size).run([&] {
std::unordered_set<COutPoint, SaltedOutpointHasher> set;
set.reserve(size);
for (const auto& outpoint : outpoints) {
set.emplace(outpoint);
}
ankerl::nanobench::doNotOptimizeAway(set.size());
});
}
static void MuHash(benchmark::Bench& bench)
{
MuHash3072 acc;
@ -276,6 +369,10 @@ BENCHMARK(SHA256_32b_SSE4, benchmark::PriorityLevel::HIGH);
BENCHMARK(SHA256_32b_AVX2, benchmark::PriorityLevel::HIGH);
BENCHMARK(SHA256_32b_SHANI, benchmark::PriorityLevel::HIGH);
BENCHMARK(SipHash_32b, benchmark::PriorityLevel::HIGH);
BENCHMARK(SaltedOutpointHasherBench_hash, benchmark::PriorityLevel::HIGH);
BENCHMARK(SaltedOutpointHasherBench_match, benchmark::PriorityLevel::HIGH);
BENCHMARK(SaltedOutpointHasherBench_mismatch, benchmark::PriorityLevel::HIGH);
BENCHMARK(SaltedOutpointHasherBench_create_set, benchmark::PriorityLevel::HIGH);
BENCHMARK(SHA256D64_1024_STANDARD, benchmark::PriorityLevel::HIGH);
BENCHMARK(SHA256D64_1024_SSE4, benchmark::PriorityLevel::HIGH);
BENCHMARK(SHA256D64_1024_AVX2, benchmark::PriorityLevel::HIGH);