sikkienl/dash
1
0
Fork 0
mirror of https://github.com/dashpay/dash.git synced 2024-12-25 20:12:57 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

bench: Tweak BLS benchmarks (#4012)

Browse Source 
* bench: Add a simple BLS signature aggregation benchmark

* bench: Tweak `BLS_*KeyAggregate_Normal` benchmarks

* bench: Adjust the expected number of iterations for `BLS_*KeyAggregate_Normal` benchmarks

* bench: Add LargeBlock*100 benchmarks, drop LargeBlock*10000 ones

These huge ones are kind of meaningless (results are ~10x slower than 1000) and it's a waste of time. Smaller ones should give an idea if there is a performance drop with the growth of the "block" size.
This commit is contained in:
UdjinM6 2021-02-28 00:15:49 +03:00 committed by GitHub
parent a281cf6b3c
commit 8ab0047d38
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 38 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

63
src/bench/bls.cpp
View File

@ -61,8 +61,7 @@ static void BLS_PubKeyAggregate_Normal(benchmark::State& state)
// Benchmark.
while (state.KeepRunning()) {
CBLSPublicKey k(pubKey1);
k.AggregateInsecure(pubKey2);
pubKey1.AggregateInsecure(pubKey2);
}
}
@ -71,13 +70,25 @@ static void BLS_SecKeyAggregate_Normal(benchmark::State& state)
CBLSSecretKey secKey1, secKey2;
secKey1.MakeNewKey();
secKey2.MakeNewKey();
CBLSPublicKey pubKey1 = secKey1.GetPublicKey();
CBLSPublicKey pubKey2 = secKey2.GetPublicKey();
// Benchmark.
while (state.KeepRunning()) {
CBLSSecretKey k(secKey1);
k.AggregateInsecure(secKey2);
secKey1.AggregateInsecure(secKey2);
}
}
static void BLS_SignatureAggregate_Normal(benchmark::State& state)
{
uint256 hash = GetRandHash();
CBLSSecretKey secKey1, secKey2;
secKey1.MakeNewKey();
secKey2.MakeNewKey();
CBLSSignature sig1 = secKey1.Sign(hash);
CBLSSignature sig2 = secKey2.Sign(hash);
// Benchmark.
while (state.KeepRunning()) {
sig1.AggregateInsecure(sig2);
}
}
@ -136,16 +147,16 @@ static void BLS_Verify_LargeBlock(size_t txCount, benchmark::State& state)
}
}
static void BLS_Verify_LargeBlock100(benchmark::State& state)
{
BLS_Verify_LargeBlock(100, state);
}
static void BLS_Verify_LargeBlock1000(benchmark::State& state)
{
BLS_Verify_LargeBlock(1000, state);
}
static void BLS_Verify_LargeBlock10000(benchmark::State& state)
{
BLS_Verify_LargeBlock(10000, state);
}
static void BLS_Verify_LargeBlockSelfAggregated(size_t txCount, benchmark::State& state)
{
BLSPublicKeyVector pubKeys;
@ -162,16 +173,16 @@ static void BLS_Verify_LargeBlockSelfAggregated(size_t txCount, benchmark::State
}
}
static void BLS_Verify_LargeBlockSelfAggregated100(benchmark::State& state)
{
BLS_Verify_LargeBlockSelfAggregated(100, state);
}
static void BLS_Verify_LargeBlockSelfAggregated1000(benchmark::State& state)
{
BLS_Verify_LargeBlockSelfAggregated(1000, state);
}
static void BLS_Verify_LargeBlockSelfAggregated10000(benchmark::State& state)
{
BLS_Verify_LargeBlockSelfAggregated(10000, state);
}
static void BLS_Verify_LargeAggregatedBlock(size_t txCount, benchmark::State& state)
{
BLSPublicKeyVector pubKeys;
@ -189,16 +200,16 @@ static void BLS_Verify_LargeAggregatedBlock(size_t txCount, benchmark::State& st
}
}
static void BLS_Verify_LargeAggregatedBlock100(benchmark::State& state)
{
BLS_Verify_LargeAggregatedBlock(100, state);
}
static void BLS_Verify_LargeAggregatedBlock1000(benchmark::State& state)
{
BLS_Verify_LargeAggregatedBlock(1000, state);
}
static void BLS_Verify_LargeAggregatedBlock10000(benchmark::State& state)
{
BLS_Verify_LargeAggregatedBlock(10000, state);
}
static void BLS_Verify_LargeAggregatedBlock1000PreVerified(benchmark::State& state)
{
BLSPublicKeyVector pubKeys;
@ -348,15 +359,17 @@ static void BLS_Verify_BatchedParallel(benchmark::State& state)
}
}
BENCHMARK(BLS_PubKeyAggregate_Normal, 300 * 1000)
BENCHMARK(BLS_SecKeyAggregate_Normal, 700 * 1000)
BENCHMARK(BLS_PubKeyAggregate_Normal, 140 * 1000)
BENCHMARK(BLS_SecKeyAggregate_Normal, 800 * 1000)
BENCHMARK(BLS_SignatureAggregate_Normal, 100 * 1000)
BENCHMARK(BLS_Sign_Normal, 600)
BENCHMARK(BLS_Verify_Normal, 350)
BENCHMARK(BLS_Verify_LargeBlock100, 3)
BENCHMARK(BLS_Verify_LargeBlock1000, 1)
BENCHMARK(BLS_Verify_LargeBlockSelfAggregated100, 7)
BENCHMARK(BLS_Verify_LargeBlockSelfAggregated1000, 1)
BENCHMARK(BLS_Verify_LargeBlockSelfAggregated10000, 1)
BENCHMARK(BLS_Verify_LargeAggregatedBlock100, 7)
BENCHMARK(BLS_Verify_LargeAggregatedBlock1000, 1)
BENCHMARK(BLS_Verify_LargeAggregatedBlock10000, 1)
BENCHMARK(BLS_Verify_LargeAggregatedBlock1000PreVerified, 5)
BENCHMARK(BLS_Verify_Batched, 500)
BENCHMARK(BLS_Verify_BatchedParallel, 1000)