Merge bitcoin/bitcoin#26158: bench: add "priority level" to the benchmark framework

src/Makefile.test.include

@@ -417,7 +417,7 @@ if TARGET_WINDOWS
 else
 if ENABLE_BENCH
 	@echo "Running bench/bench_dash (one iteration sanity check, only high priority)..."
-	$(BENCH_BINARY) -sanity-check -priority-level=high
+	$(BENCH_BINARY) -sanity-check -priority-level=high > /dev/null
 endif
 endif
 	$(AM_V_at)$(MAKE) $(AM_MAKEFLAGS) -C secp256k1 check

src/bench/addrman.cpp

@@ -167,9 +167,9 @@ static void AddrManAddThenGood(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(AddrManAdd);
-BENCHMARK(AddrManSelect);
-BENCHMARK(AddrManSelectFromAlmostEmpty);
-BENCHMARK(AddrManSelectByNetwork);
-BENCHMARK(AddrManGetAddr);
-BENCHMARK(AddrManAddThenGood);
+BENCHMARK(AddrManAdd, benchmark::PriorityLevel::HIGH);
+BENCHMARK(AddrManSelect, benchmark::PriorityLevel::HIGH);
+BENCHMARK(AddrManSelectFromAlmostEmpty, benchmark::PriorityLevel::HIGH);
+BENCHMARK(AddrManSelectByNetwork, benchmark::PriorityLevel::HIGH);
+BENCHMARK(AddrManGetAddr, benchmark::PriorityLevel::HIGH);
+BENCHMARK(AddrManAddThenGood, benchmark::PriorityLevel::HIGH);

src/bench/base58.cpp

@@ -50,6 +50,6 @@ static void Base58Decode(benchmark::Bench& bench)
 }
 
 
-BENCHMARK(Base58Encode);
-BENCHMARK(Base58CheckEncode);
-BENCHMARK(Base58Decode);
+BENCHMARK(Base58Encode, benchmark::PriorityLevel::HIGH);
+BENCHMARK(Base58CheckEncode, benchmark::PriorityLevel::HIGH);
+BENCHMARK(Base58Decode, benchmark::PriorityLevel::HIGH);

src/bench/bech32.cpp

@@ -32,5 +32,5 @@ static void Bech32Decode(benchmark::Bench& bench)
 }
 
 
-BENCHMARK(Bech32Encode);
-BENCHMARK(Bech32Decode);
+BENCHMARK(Bech32Encode, benchmark::PriorityLevel::HIGH);
+BENCHMARK(Bech32Decode, benchmark::PriorityLevel::HIGH);

src/bench/bench.h

@@ -75,8 +75,8 @@ class BenchRunner
 };
 } // namespace benchmark
 
-// BENCHMARK(foo) expands to:  benchmark::BenchRunner bench_11foo("foo", foo, priority_level);
-#define BENCHMARK(n) \
-    benchmark::BenchRunner PASTE2(bench_, PASTE2(__LINE__, n))(STRINGIZE(n), n, benchmark::PriorityLevel::HIGH);
+// BENCHMARK(foo, priority_level) expands to:  benchmark::BenchRunner bench_11foo("foo", foo, priority_level);
+#define BENCHMARK(n, priority_level) \
+    benchmark::BenchRunner PASTE2(bench_, PASTE2(__LINE__, n))(STRINGIZE(n), n, priority_level);
 
 #endif // BITCOIN_BENCH_BENCH_H

src/bench/bench_bitcoin.cpp

@@ -33,7 +33,7 @@ static void SetupBenchArgs(ArgsManager& argsman)
     argsman.AddArg("-min-time=<milliseconds>", strprintf("Minimum runtime per benchmark, in milliseconds (default: %d)", DEFAULT_MIN_TIME_MS), ArgsManager::ALLOW_ANY | ArgsManager::DISALLOW_NEGATION, OptionsCategory::OPTIONS);
     argsman.AddArg("-output-csv=<output.csv>", "Generate CSV file with the most important benchmark results", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-output-json=<output.json>", "Generate JSON file with all benchmark results", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
-    argsman.AddArg("-sanity-check", "Run benchmarks for only one iteration with no output", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
+    argsman.AddArg("-sanity-check", "Run benchmarks for only one iteration", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-priority-level=<l1,l2,l3>", strprintf("Run benchmarks of one or multiple priority level(s) (%s), default: '%s'",
                                                            benchmark::ListPriorities(), DEFAULT_PRIORITY), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
 }

src/bench/bip324_ecdh.cpp

@@ -48,4 +48,4 @@ static void BIP324_ECDH(benchmark::Bench& bench)
     ECC_Stop();
 }
 
-BENCHMARK(BIP324_ECDH);
+BENCHMARK(BIP324_ECDH, benchmark::PriorityLevel::HIGH);

src/bench/block_assemble.cpp

@@ -52,4 +52,4 @@ static void AssembleBlock(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(AssembleBlock);
+BENCHMARK(AssembleBlock, benchmark::PriorityLevel::HIGH);

src/bench/bls.cpp

@@ -358,17 +358,17 @@ static void BLS_Verify_BatchedParallel(benchmark::Bench& bench)
     blsWorker.Stop();
 }
 
-BENCHMARK(BLS_PubKeyAggregate_Normal)
-BENCHMARK(BLS_SecKeyAggregate_Normal)
-BENCHMARK(BLS_SignatureAggregate_Normal)
-BENCHMARK(BLS_Sign_Normal)
-BENCHMARK(BLS_Verify_Normal)
-BENCHMARK(BLS_Verify_LargeBlock100)
-BENCHMARK(BLS_Verify_LargeBlock1000)
-BENCHMARK(BLS_Verify_LargeBlockSelfAggregated100)
-BENCHMARK(BLS_Verify_LargeBlockSelfAggregated1000)
-BENCHMARK(BLS_Verify_LargeAggregatedBlock100)
-BENCHMARK(BLS_Verify_LargeAggregatedBlock1000)
-BENCHMARK(BLS_Verify_LargeAggregatedBlock1000PreVerified)
-BENCHMARK(BLS_Verify_Batched)
-BENCHMARK(BLS_Verify_BatchedParallel)
+BENCHMARK(BLS_PubKeyAggregate_Normal, benchmark::PriorityLevel::HIGH);
+BENCHMARK(BLS_SecKeyAggregate_Normal, benchmark::PriorityLevel::HIGH);
+BENCHMARK(BLS_SignatureAggregate_Normal, benchmark::PriorityLevel::HIGH);
+BENCHMARK(BLS_Sign_Normal, benchmark::PriorityLevel::HIGH);
+BENCHMARK(BLS_Verify_Normal, benchmark::PriorityLevel::HIGH);
+BENCHMARK(BLS_Verify_LargeBlock100, benchmark::PriorityLevel::HIGH);
+BENCHMARK(BLS_Verify_LargeBlock1000, benchmark::PriorityLevel::HIGH);
+BENCHMARK(BLS_Verify_LargeBlockSelfAggregated100, benchmark::PriorityLevel::HIGH);
+BENCHMARK(BLS_Verify_LargeBlockSelfAggregated1000, benchmark::PriorityLevel::HIGH);
+BENCHMARK(BLS_Verify_LargeAggregatedBlock100, benchmark::PriorityLevel::HIGH);
+BENCHMARK(BLS_Verify_LargeAggregatedBlock1000, benchmark::PriorityLevel::HIGH);
+BENCHMARK(BLS_Verify_LargeAggregatedBlock1000PreVerified, benchmark::PriorityLevel::HIGH);
+BENCHMARK(BLS_Verify_Batched, benchmark::PriorityLevel::HIGH);
+BENCHMARK(BLS_Verify_BatchedParallel, benchmark::PriorityLevel::HIGH);

src/bench/bls_dkg.cpp

@@ -136,7 +136,7 @@ static void BLSDKG_GenerateContributions(benchmark::Bench& bench, uint32_t epoch
     {                                                \
         BLSDKG_GenerateContributions(bench, epoch_iters, quorumSize); \
     } \
-    BENCHMARK(BLSDKG_GenerateContributions_##name##_##quorumSize)
+    BENCHMARK(BLSDKG_GenerateContributions_##name##_##quorumSize, benchmark::PriorityLevel::HIGH)
 
 static void BLSDKG_InitDKG(benchmark::Bench& bench, uint32_t epoch_iters, int quorumSize)
 {
@@ -154,7 +154,7 @@ static void BLSDKG_InitDKG(benchmark::Bench& bench, uint32_t epoch_iters, int qu
     {                                                \
         BLSDKG_InitDKG(bench, epoch_iters, quorumSize); \
     } \
-    BENCHMARK(BLSDKG_InitDKG_##name##_##quorumSize)
+    BENCHMARK(BLSDKG_InitDKG_##name##_##quorumSize, benchmark::PriorityLevel::HIGH)
 
 #define BENCH_BuildQuorumVerificationVectors(name, quorumSize, epoch_iters) \
     static void BLSDKG_BuildQuorumVerificationVectors_##name##_##quorumSize(benchmark::Bench& bench) \
@@ -169,7 +169,7 @@ static void BLSDKG_InitDKG(benchmark::Bench& bench, uint32_t epoch_iters, int qu
         ptr->Bench_BuildQuorumVerificationVectors(bench, epoch_iters); \
         ptr.reset(); \
     } \
-    BENCHMARK(BLSDKG_BuildQuorumVerificationVectors_##name##_##quorumSize)
+    BENCHMARK(BLSDKG_BuildQuorumVerificationVectors_##name##_##quorumSize, benchmark::PriorityLevel::HIGH)
 
 #define BENCH_VerifyContributionShares(name, quorumSize, invalidCount, aggregated, epoch_iters) \
     static void BLSDKG_VerifyContributionShares_##name##_##quorumSize(benchmark::Bench& bench) \
@@ -184,7 +184,7 @@ static void BLSDKG_InitDKG(benchmark::Bench& bench, uint32_t epoch_iters, int qu
         ptr->Bench_VerifyContributionShares(bench, invalidCount, aggregated, epoch_iters); \
         ptr.reset(); \
     } \
-    BENCHMARK(BLSDKG_VerifyContributionShares_##name##_##quorumSize)
+    BENCHMARK(BLSDKG_VerifyContributionShares_##name##_##quorumSize, benchmark::PriorityLevel::HIGH)
 
 BENCH_GenerateContributions(simple, 50, 50);
 BENCH_GenerateContributions(simple, 100, 5);

src/bench/bls_pubkey_agg.cpp

@@ -87,13 +87,13 @@ static void BLS_PubKeyAggregate_Iterative_200(benchmark::Bench& bench) { BLS_Pub
 static void BLS_PubKeyAggregate_Batch_200(benchmark::Bench& bench) { BLS_PubKeyAggregate_Batch(200, bench); }
 
 // Register all benchmarks
-BENCHMARK(BLS_PubKeyAggregate_Iterative_5)
-BENCHMARK(BLS_PubKeyAggregate_Batch_5)
-BENCHMARK(BLS_PubKeyAggregate_Iterative_25)
-BENCHMARK(BLS_PubKeyAggregate_Batch_25)
-BENCHMARK(BLS_PubKeyAggregate_Iterative_50)
-BENCHMARK(BLS_PubKeyAggregate_Batch_50)
-BENCHMARK(BLS_PubKeyAggregate_Iterative_100)
-BENCHMARK(BLS_PubKeyAggregate_Batch_100)
-BENCHMARK(BLS_PubKeyAggregate_Iterative_200)
-BENCHMARK(BLS_PubKeyAggregate_Batch_200)
+BENCHMARK(BLS_PubKeyAggregate_Iterative_5, benchmark::PriorityLevel::HIGH);
+BENCHMARK(BLS_PubKeyAggregate_Batch_5, benchmark::PriorityLevel::HIGH);
+BENCHMARK(BLS_PubKeyAggregate_Iterative_25, benchmark::PriorityLevel::HIGH);
+BENCHMARK(BLS_PubKeyAggregate_Batch_25, benchmark::PriorityLevel::HIGH);
+BENCHMARK(BLS_PubKeyAggregate_Iterative_50, benchmark::PriorityLevel::HIGH);
+BENCHMARK(BLS_PubKeyAggregate_Batch_50, benchmark::PriorityLevel::HIGH);
+BENCHMARK(BLS_PubKeyAggregate_Iterative_100, benchmark::PriorityLevel::HIGH);
+BENCHMARK(BLS_PubKeyAggregate_Batch_100, benchmark::PriorityLevel::HIGH);
+BENCHMARK(BLS_PubKeyAggregate_Iterative_200, benchmark::PriorityLevel::HIGH);
+BENCHMARK(BLS_PubKeyAggregate_Batch_200, benchmark::PriorityLevel::HIGH);

src/bench/ccoins_caching.cpp

@@ -50,4 +50,4 @@ static void CCoinsCaching(benchmark::Bench& bench)
     ECC_Stop();
 }
 
-BENCHMARK(CCoinsCaching);
+BENCHMARK(CCoinsCaching, benchmark::PriorityLevel::HIGH);

src/bench/chacha20.cpp

@@ -66,9 +66,9 @@ static void FSCHACHA20POLY1305_1MB(benchmark::Bench& bench)
     FSCHACHA20POLY1305(bench, BUFFER_SIZE_LARGE);
 }
 
-BENCHMARK(CHACHA20_64BYTES);
-BENCHMARK(CHACHA20_256BYTES);
-BENCHMARK(CHACHA20_1MB);
-BENCHMARK(FSCHACHA20POLY1305_64BYTES);
-BENCHMARK(FSCHACHA20POLY1305_256BYTES);
-BENCHMARK(FSCHACHA20POLY1305_1MB);
+BENCHMARK(CHACHA20_64BYTES, benchmark::PriorityLevel::HIGH);
+BENCHMARK(CHACHA20_256BYTES, benchmark::PriorityLevel::HIGH);
+BENCHMARK(CHACHA20_1MB, benchmark::PriorityLevel::HIGH);
+BENCHMARK(FSCHACHA20POLY1305_64BYTES, benchmark::PriorityLevel::HIGH);
+BENCHMARK(FSCHACHA20POLY1305_256BYTES, benchmark::PriorityLevel::HIGH);
+BENCHMARK(FSCHACHA20POLY1305_1MB, benchmark::PriorityLevel::HIGH);

src/bench/checkblock.cpp

@@ -56,5 +56,5 @@ static void DeserializeAndCheckBlockTest(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(DeserializeBlockTest);
-BENCHMARK(DeserializeAndCheckBlockTest);
+BENCHMARK(DeserializeBlockTest, benchmark::PriorityLevel::HIGH);
+BENCHMARK(DeserializeAndCheckBlockTest, benchmark::PriorityLevel::HIGH);

src/bench/checkqueue.cpp

@@ -70,4 +70,4 @@ static void CCheckQueueSpeedPrevectorJob(benchmark::Bench& bench)
     queue.StopWorkerThreads();
     ECC_Stop();
 }
-BENCHMARK(CCheckQueueSpeedPrevectorJob);
+BENCHMARK(CCheckQueueSpeedPrevectorJob, benchmark::PriorityLevel::HIGH);

src/bench/coin_selection.cpp

@@ -118,5 +118,5 @@ static void BnBExhaustion(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(CoinSelection);
-BENCHMARK(BnBExhaustion);
+BENCHMARK(CoinSelection, benchmark::PriorityLevel::HIGH);
+BENCHMARK(BnBExhaustion, benchmark::PriorityLevel::HIGH);

src/bench/crypto_hash.cpp

@@ -258,31 +258,31 @@ static void MuHashPrecompute(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(BenchRIPEMD160);
-BENCHMARK(SHA1);
-BENCHMARK(SHA256_STANDARD);
-BENCHMARK(SHA256_SSE4);
-BENCHMARK(SHA256_AVX2);
-BENCHMARK(SHA256_SHANI);
-BENCHMARK(SHA512);
-BENCHMARK(SHA3_256_1M);
-
-BENCHMARK(SHA256_32b_STANDARD);
-BENCHMARK(SHA256_32b_SSE4);
-BENCHMARK(SHA256_32b_AVX2);
-BENCHMARK(SHA256_32b_SHANI);
-BENCHMARK(SipHash_32b);
-BENCHMARK(SHA256D64_1024_STANDARD);
-BENCHMARK(SHA256D64_1024_SSE4);
-BENCHMARK(SHA256D64_1024_AVX2);
-BENCHMARK(SHA256D64_1024_SHANI);
-BENCHMARK(FastRandom_32bit);
-BENCHMARK(FastRandom_1bit);
-
-BENCHMARK(MuHash);
-BENCHMARK(MuHashMul);
-BENCHMARK(MuHashDiv);
-BENCHMARK(MuHashPrecompute);
+BENCHMARK(BenchRIPEMD160, benchmark::PriorityLevel::HIGH);
+BENCHMARK(SHA1, benchmark::PriorityLevel::HIGH);
+BENCHMARK(SHA256_STANDARD, benchmark::PriorityLevel::HIGH);
+BENCHMARK(SHA256_SSE4, benchmark::PriorityLevel::HIGH);
+BENCHMARK(SHA256_AVX2, benchmark::PriorityLevel::HIGH);
+BENCHMARK(SHA256_SHANI, benchmark::PriorityLevel::HIGH);
+BENCHMARK(SHA512, benchmark::PriorityLevel::HIGH);
+BENCHMARK(SHA3_256_1M, benchmark::PriorityLevel::HIGH);
+
+BENCHMARK(SHA256_32b_STANDARD, benchmark::PriorityLevel::HIGH);
+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(SHA256D64_1024_STANDARD, benchmark::PriorityLevel::HIGH);
+BENCHMARK(SHA256D64_1024_SSE4, benchmark::PriorityLevel::HIGH);
+BENCHMARK(SHA256D64_1024_AVX2, benchmark::PriorityLevel::HIGH);
+BENCHMARK(SHA256D64_1024_SHANI, benchmark::PriorityLevel::HIGH);
+BENCHMARK(FastRandom_32bit, benchmark::PriorityLevel::HIGH);
+BENCHMARK(FastRandom_1bit, benchmark::PriorityLevel::HIGH);
+
+BENCHMARK(MuHash, benchmark::PriorityLevel::HIGH);
+BENCHMARK(MuHashMul, benchmark::PriorityLevel::HIGH);
+BENCHMARK(MuHashDiv, benchmark::PriorityLevel::HIGH);
+BENCHMARK(MuHashPrecompute, benchmark::PriorityLevel::HIGH);
 
 /* --------------------------- Dash-specific tests start here --------------------------- */
 
@@ -350,11 +350,11 @@ static void DSHA256_2048b_single(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(DSHA256_1M);
+BENCHMARK(DSHA256_1M, benchmark::PriorityLevel::HIGH);
 
-BENCHMARK(DSHA256_0032b_single);
-BENCHMARK(DSHA256_0080b_single);
-BENCHMARK(DSHA256_0128b_single);
-BENCHMARK(DSHA256_0512b_single);
-BENCHMARK(DSHA256_1024b_single);
-BENCHMARK(DSHA256_2048b_single);
+BENCHMARK(DSHA256_0032b_single, benchmark::PriorityLevel::HIGH);
+BENCHMARK(DSHA256_0080b_single, benchmark::PriorityLevel::HIGH);
+BENCHMARK(DSHA256_0128b_single, benchmark::PriorityLevel::HIGH);
+BENCHMARK(DSHA256_0512b_single, benchmark::PriorityLevel::HIGH);
+BENCHMARK(DSHA256_1024b_single, benchmark::PriorityLevel::HIGH);
+BENCHMARK(DSHA256_2048b_single, benchmark::PriorityLevel::HIGH);

src/bench/duplicate_inputs.cpp

@@ -61,4 +61,4 @@ static void DuplicateInputs(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(DuplicateInputs);
+BENCHMARK(DuplicateInputs, benchmark::PriorityLevel::HIGH);

src/bench/ecdsa.cpp

@@ -84,6 +84,6 @@ static void ECDSAVerify_LargeBlock(benchmark::Bench& bench)
     ECC_Stop();
 }
 
-BENCHMARK(ECDSASign)
-BENCHMARK(ECDSAVerify)
-BENCHMARK(ECDSAVerify_LargeBlock)
+BENCHMARK(ECDSASign, benchmark::PriorityLevel::HIGH);
+BENCHMARK(ECDSAVerify, benchmark::PriorityLevel::HIGH);
+BENCHMARK(ECDSAVerify_LargeBlock, benchmark::PriorityLevel::HIGH);

src/bench/ellswift.cpp

@@ -28,4 +28,4 @@ static void EllSwiftCreate(benchmark::Bench& bench)
     ECC_Stop();
 }
 
-BENCHMARK(EllSwiftCreate);
+BENCHMARK(EllSwiftCreate, benchmark::PriorityLevel::HIGH);

src/bench/examples.cpp

@@ -18,4 +18,4 @@ static void Trig(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(Trig);
+BENCHMARK(Trig, benchmark::PriorityLevel::HIGH);

src/bench/gcs_filter.cpp

@@ -81,8 +81,8 @@ static void GCSFilterMatch(benchmark::Bench& bench)
         filter.Match(GCSFilter::Element());
     });
 }
-BENCHMARK(GCSBlockFilterGetHash);
-BENCHMARK(GCSFilterConstruct);
-BENCHMARK(GCSFilterDecode);
-BENCHMARK(GCSFilterDecodeSkipCheck);
-BENCHMARK(GCSFilterMatch);
+BENCHMARK(GCSBlockFilterGetHash, benchmark::PriorityLevel::HIGH);
+BENCHMARK(GCSFilterConstruct, benchmark::PriorityLevel::HIGH);
+BENCHMARK(GCSFilterDecode, benchmark::PriorityLevel::HIGH);
+BENCHMARK(GCSFilterDecodeSkipCheck, benchmark::PriorityLevel::HIGH);
+BENCHMARK(GCSFilterMatch, benchmark::PriorityLevel::HIGH);

src/bench/hashpadding.cpp

@@ -26,7 +26,7 @@ static void PrePadded(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(PrePadded);
+BENCHMARK(PrePadded, benchmark::PriorityLevel::HIGH);
 
 static void RegularPadded(benchmark::Bench& bench)
 {
@@ -44,4 +44,4 @@ static void RegularPadded(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(RegularPadded);
+BENCHMARK(RegularPadded, benchmark::PriorityLevel::HIGH);

src/bench/load_external.cpp

@@ -60,4 +60,4 @@ static void LoadExternalBlockFile(benchmark::Bench& bench)
     fs::remove(blkfile);
 }
 
-BENCHMARK(LoadExternalBlockFile);
+BENCHMARK(LoadExternalBlockFile, benchmark::PriorityLevel::HIGH);

src/bench/lockedpool.cpp

@@ -39,4 +39,4 @@ static void BenchLockedPool(benchmark::Bench& bench)
     addr.clear();
 }
 
-BENCHMARK(BenchLockedPool);
+BENCHMARK(BenchLockedPool, benchmark::PriorityLevel::HIGH);

src/bench/logging.cpp

@@ -41,8 +41,8 @@ static void LoggingNoFile(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(LoggingYoThreadNames);
-BENCHMARK(LoggingNoThreadNames);
-BENCHMARK(LoggingYoCategory);
-BENCHMARK(LoggingNoCategory);
-BENCHMARK(LoggingNoFile);
+BENCHMARK(LoggingYoThreadNames, benchmark::PriorityLevel::HIGH);
+BENCHMARK(LoggingNoThreadNames, benchmark::PriorityLevel::HIGH);
+BENCHMARK(LoggingYoCategory, benchmark::PriorityLevel::HIGH);
+BENCHMARK(LoggingNoCategory, benchmark::PriorityLevel::HIGH);
+BENCHMARK(LoggingNoFile, benchmark::PriorityLevel::HIGH);

src/bench/mempool_eviction.cpp

@@ -122,4 +122,4 @@ static void MempoolEviction(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(MempoolEviction);
+BENCHMARK(MempoolEviction, benchmark::PriorityLevel::HIGH);

src/bench/mempool_stress.cpp

@@ -112,5 +112,5 @@ static void MempoolCheck(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(ComplexMemPool);
-BENCHMARK(MempoolCheck);
+BENCHMARK(ComplexMemPool, benchmark::PriorityLevel::HIGH);
+BENCHMARK(MempoolCheck, benchmark::PriorityLevel::HIGH);

src/bench/merkle_root.cpp

@@ -23,4 +23,4 @@ static void MerkleRoot(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(MerkleRoot);
+BENCHMARK(MerkleRoot, benchmark::PriorityLevel::HIGH);