uint256_blob.cpp

Go to the documentation of this file.

// Copyright (c) The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or https://opensource.org/license/mit.
 
#include <bench/bench.h>
#include <random.h>
#include <uint256.h>
 
#include <compare>
#include <cstddef>
#include <utility>
#include <vector>
 
namespace {
 
enum class Difference {
    NONE,
    FIRST_BYTE,
    LAST_BYTE,
};
 
constexpr size_t NUM_PAIRS{4'096};
 
std::vector<std::pair<uint256, uint256>> MakePairs(Difference difference)
{
    FastRandomContext rng{/*fDeterministic=*/true};
    std::vector<std::pair<uint256, uint256>> pairs;
    pairs.reserve(NUM_PAIRS);
 
    for (size_t i{0}; i < NUM_PAIRS; ++i) {
        uint256 lhs{rng.rand256()};
        uint256 rhs{lhs};
        if (difference != Difference::NONE) {
            const size_t position{difference == Difference::FIRST_BYTE ? 0 : uint256::size() - 1};
            lhs.begin()[position] = i % 2 == 0 ? 0 : 255;
            rhs.begin()[position] = i % 2 == 0 ? 255 : 0;
        }
        pairs.emplace_back(lhs, rhs);
    }
    return pairs;
}
 
template <typename Comparator>
void Comparison(benchmark::Bench& bench, Difference difference, Comparator comparator)
{
    const auto pairs{MakePairs(difference)};
    bench.batch(pairs.size()).unit("comparison").run([&] {
        for (const auto& [lhs, rhs] : pairs) {
            ankerl::nanobench::doNotOptimizeAway(comparator(lhs, rhs));
        }
    });
}
 
void Uint256EqualIdentical(benchmark::Bench& bench)
{
    Comparison(bench, Difference::NONE, [](const uint256& lhs, const uint256& rhs) { return lhs == rhs; });
}
 
void Uint256EqualFirstByteDifferent(benchmark::Bench& bench)
{
    Comparison(bench, Difference::FIRST_BYTE, [](const uint256& lhs, const uint256& rhs) { return lhs == rhs; });
}
 
void Uint256EqualLastByteDifferent(benchmark::Bench& bench)
{
    Comparison(bench, Difference::LAST_BYTE, [](const uint256& lhs, const uint256& rhs) { return lhs == rhs; });
}
 
void Uint256LessIdentical(benchmark::Bench& bench)
{
    Comparison(bench, Difference::NONE, [](const uint256& lhs, const uint256& rhs) { return lhs < rhs; });
}
 
void Uint256LessFirstByteDifferent(benchmark::Bench& bench)
{
    Comparison(bench, Difference::FIRST_BYTE, [](const uint256& lhs, const uint256& rhs) { return lhs < rhs; });
}
 
void Uint256LessLastByteDifferent(benchmark::Bench& bench)
{
    Comparison(bench, Difference::LAST_BYTE, [](const uint256& lhs, const uint256& rhs) { return lhs < rhs; });
}
 
} // namespace
 
BENCHMARK(Uint256EqualIdentical);
BENCHMARK(Uint256EqualFirstByteDifferent);
BENCHMARK(Uint256EqualLastByteDifferent);
BENCHMARK(Uint256LessIdentical);
BENCHMARK(Uint256LessFirstByteDifferent);
BENCHMARK(Uint256LessLastByteDifferent);