scripted-diff: Remove priority_level from BENCHMARK macro

-BEGIN VERIFY SCRIPT-

 sed --in-place --regexp-extended 's/BENCHMARK\(([^,]+), benchmark::PriorityLevel::(HIGH|LOW)\)/BENCHMARK(\1)/g' $( git grep -l PriorityLevel )
 sed --in-place                   's/#define BENCHMARK(n, priority_level)/#define BENCHMARK(n)/g'                ./src/bench/bench.h

-END VERIFY SCRIPT-

src/bench/addrman.cpp

@@ -175,9 +175,9 @@ static void AddrManAddThenGood(benchmark::Bench& bench)
     });
 }
 
-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);
+BENCHMARK(AddrManAdd);
+BENCHMARK(AddrManSelect);
+BENCHMARK(AddrManSelectFromAlmostEmpty);
+BENCHMARK(AddrManSelectByNetwork);
+BENCHMARK(AddrManGetAddr);
+BENCHMARK(AddrManAddThenGood);

src/bench/base58.cpp

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

src/bench/bech32.cpp

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

src/bench/bench.h

@@ -65,7 +65,7 @@ public:
 } // namespace benchmark
 
 // BENCHMARK(foo) expands to:  benchmark::BenchRunner bench_11foo{"foo", foo};
-#define BENCHMARK(n, priority_level) \
+#define BENCHMARK(n) \
     benchmark::BenchRunner PASTE2(bench_, PASTE2(__LINE__, n)){STRINGIZE(n), n};
 
 #endif // BITCOIN_BENCH_BENCH_H

src/bench/bip324_ecdh.cpp

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

src/bench/block_assemble.cpp

@@ -69,5 +69,5 @@ static void BlockAssemblerAddPackageTxns(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(AssembleBlock, benchmark::PriorityLevel::HIGH);
-BENCHMARK(BlockAssemblerAddPackageTxns, benchmark::PriorityLevel::LOW);
+BENCHMARK(AssembleBlock);
+BENCHMARK(BlockAssemblerAddPackageTxns);

src/bench/blockencodings.cpp

@@ -126,6 +126,6 @@ static void BlockEncodingLargeExtra(benchmark::Bench& bench)
     BlockEncodingBench(bench, 50000, 5000);
 }
 
-BENCHMARK(BlockEncodingNoExtra, benchmark::PriorityLevel::HIGH);
-BENCHMARK(BlockEncodingStdExtra, benchmark::PriorityLevel::HIGH);
-BENCHMARK(BlockEncodingLargeExtra, benchmark::PriorityLevel::HIGH);
+BENCHMARK(BlockEncodingNoExtra);
+BENCHMARK(BlockEncodingStdExtra);
+BENCHMARK(BlockEncodingLargeExtra);

src/bench/ccoins_caching.cpp

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

src/bench/chacha20.cpp

@@ -71,9 +71,9 @@ static void FSCHACHA20POLY1305_1MB(benchmark::Bench& bench)
     FSCHACHA20POLY1305(bench, BUFFER_SIZE_LARGE);
 }
 
-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);
+BENCHMARK(CHACHA20_64BYTES);
+BENCHMARK(CHACHA20_256BYTES);
+BENCHMARK(CHACHA20_1MB);
+BENCHMARK(FSCHACHA20POLY1305_64BYTES);
+BENCHMARK(FSCHACHA20POLY1305_256BYTES);
+BENCHMARK(FSCHACHA20POLY1305_1MB);

src/bench/checkblock.cpp

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

src/bench/checkblockindex.cpp

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

src/bench/checkqueue.cpp

@@ -65,4 +65,4 @@ static void CCheckQueueSpeedPrevectorJob(benchmark::Bench& bench)
         control.Complete();
     });
 }
-BENCHMARK(CCheckQueueSpeedPrevectorJob, benchmark::PriorityLevel::HIGH);
+BENCHMARK(CCheckQueueSpeedPrevectorJob);

src/bench/cluster_linearize.cpp

@@ -150,12 +150,12 @@ static void LinearizeOptimallyPerCost(benchmark::Bench& bench)
     BenchLinearizeOptimallyPerCost(bench, "LinearizeOptimallySyntheticPerCost", CLUSTERS_SYNTHETIC);
 }
 
-BENCHMARK(PostLinearize16TxWorstCase, benchmark::PriorityLevel::HIGH);
-BENCHMARK(PostLinearize32TxWorstCase, benchmark::PriorityLevel::HIGH);
-BENCHMARK(PostLinearize48TxWorstCase, benchmark::PriorityLevel::HIGH);
-BENCHMARK(PostLinearize64TxWorstCase, benchmark::PriorityLevel::HIGH);
-BENCHMARK(PostLinearize75TxWorstCase, benchmark::PriorityLevel::HIGH);
-BENCHMARK(PostLinearize99TxWorstCase, benchmark::PriorityLevel::HIGH);
+BENCHMARK(PostLinearize16TxWorstCase);
+BENCHMARK(PostLinearize32TxWorstCase);
+BENCHMARK(PostLinearize48TxWorstCase);
+BENCHMARK(PostLinearize64TxWorstCase);
+BENCHMARK(PostLinearize75TxWorstCase);
+BENCHMARK(PostLinearize99TxWorstCase);
 
-BENCHMARK(LinearizeOptimallyTotal, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LinearizeOptimallyPerCost, benchmark::PriorityLevel::HIGH);
+BENCHMARK(LinearizeOptimallyTotal);
+BENCHMARK(LinearizeOptimallyPerCost);

src/bench/coin_selection.cpp

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

src/bench/connectblock.cpp

@@ -126,6 +126,6 @@ static void ConnectBlockAllEcdsa(benchmark::Bench& bench)
     BenchmarkConnectBlock(bench, keys, outputs, *test_setup);
 }
 
-BENCHMARK(ConnectBlockAllSchnorr, benchmark::PriorityLevel::HIGH);
-BENCHMARK(ConnectBlockMixedEcdsaSchnorr, benchmark::PriorityLevel::HIGH);
-BENCHMARK(ConnectBlockAllEcdsa, benchmark::PriorityLevel::HIGH);
+BENCHMARK(ConnectBlockAllSchnorr);
+BENCHMARK(ConnectBlockMixedEcdsaSchnorr);
+BENCHMARK(ConnectBlockAllEcdsa);

src/bench/crypto_hash.cpp

@@ -260,27 +260,27 @@ static void MuHashFinalize(benchmark::Bench& bench)
     });
 }
 
-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(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::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(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(MuHash, benchmark::PriorityLevel::HIGH);
-BENCHMARK(MuHashMul, benchmark::PriorityLevel::HIGH);
-BENCHMARK(MuHashDiv, benchmark::PriorityLevel::HIGH);
-BENCHMARK(MuHashPrecompute, benchmark::PriorityLevel::HIGH);
-BENCHMARK(MuHashFinalize, benchmark::PriorityLevel::HIGH);
+BENCHMARK(MuHash);
+BENCHMARK(MuHashMul);
+BENCHMARK(MuHashDiv);
+BENCHMARK(MuHashPrecompute);
+BENCHMARK(MuHashFinalize);

src/bench/descriptors.cpp

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

src/bench/disconnected_transactions.cpp

@@ -134,6 +134,6 @@ static void AddAndRemoveDisconnectedBlockTransactions10(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(AddAndRemoveDisconnectedBlockTransactionsAll, benchmark::PriorityLevel::HIGH);
-BENCHMARK(AddAndRemoveDisconnectedBlockTransactions90, benchmark::PriorityLevel::HIGH);
-BENCHMARK(AddAndRemoveDisconnectedBlockTransactions10, benchmark::PriorityLevel::HIGH);
+BENCHMARK(AddAndRemoveDisconnectedBlockTransactionsAll);
+BENCHMARK(AddAndRemoveDisconnectedBlockTransactions90);
+BENCHMARK(AddAndRemoveDisconnectedBlockTransactions10);

src/bench/duplicate_inputs.cpp

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

src/bench/ellswift.cpp

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

src/bench/examples.cpp

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

src/bench/gcs_filter.cpp

@@ -86,8 +86,8 @@ static void GCSFilterMatch(benchmark::Bench& bench)
         filter.Match(GCSFilter::Element());
     });
 }
-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);
+BENCHMARK(GCSBlockFilterGetHash);
+BENCHMARK(GCSFilterConstruct);
+BENCHMARK(GCSFilterDecode);
+BENCHMARK(GCSFilterDecodeSkipCheck);
+BENCHMARK(GCSFilterMatch);

src/bench/hashpadding.cpp

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

src/bench/index_blockfilter.cpp

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

src/bench/load_external.cpp

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

src/bench/lockedpool.cpp

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

src/bench/logging.cpp

@@ -57,8 +57,8 @@ static void LogWithoutWriteToFile(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(LogWithDebug, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LogWithoutDebug, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LogWithThreadNames, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LogWithoutThreadNames, benchmark::PriorityLevel::HIGH);
-BENCHMARK(LogWithoutWriteToFile, benchmark::PriorityLevel::HIGH);
+BENCHMARK(LogWithDebug);
+BENCHMARK(LogWithoutDebug);
+BENCHMARK(LogWithThreadNames);
+BENCHMARK(LogWithoutThreadNames);
+BENCHMARK(LogWithoutWriteToFile);

src/bench/mempool_ephemeral_spends.cpp

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

src/bench/mempool_eviction.cpp

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

src/bench/mempool_stress.cpp

@@ -208,7 +208,7 @@ static void MempoolCheck(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(MemPoolAncestorsDescendants, benchmark::PriorityLevel::HIGH);
-BENCHMARK(MemPoolAddTransactions, benchmark::PriorityLevel::HIGH);
-BENCHMARK(ComplexMemPool, benchmark::PriorityLevel::HIGH);
-BENCHMARK(MempoolCheck, benchmark::PriorityLevel::HIGH);
+BENCHMARK(MemPoolAncestorsDescendants);
+BENCHMARK(MemPoolAddTransactions);
+BENCHMARK(ComplexMemPool);
+BENCHMARK(MempoolCheck);

src/bench/merkle_root.cpp

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

src/bench/obfuscation.cpp

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

src/bench/parse_hex.cpp

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

src/bench/peer_eviction.cpp

@@ -140,15 +140,15 @@ static void EvictionProtection3Networks250Candidates(benchmark::Bench& bench)
 // - 250 candidates is the number of peers reported by operators of busy nodes
 
 // No disadvantaged networks, with 250 eviction candidates.
-BENCHMARK(EvictionProtection0Networks250Candidates, benchmark::PriorityLevel::HIGH);
+BENCHMARK(EvictionProtection0Networks250Candidates);
 
 // 1 disadvantaged network (Tor) with 250 eviction candidates.
-BENCHMARK(EvictionProtection1Networks250Candidates, benchmark::PriorityLevel::HIGH);
+BENCHMARK(EvictionProtection1Networks250Candidates);
 
 // 2 disadvantaged networks (I2P, Tor) with 250 eviction candidates.
-BENCHMARK(EvictionProtection2Networks250Candidates, benchmark::PriorityLevel::HIGH);
+BENCHMARK(EvictionProtection2Networks250Candidates);
 
 // 3 disadvantaged networks (I2P/localhost/Tor) with 50/100/250 eviction candidates.
-BENCHMARK(EvictionProtection3Networks050Candidates, benchmark::PriorityLevel::HIGH);
-BENCHMARK(EvictionProtection3Networks100Candidates, benchmark::PriorityLevel::HIGH);
-BENCHMARK(EvictionProtection3Networks250Candidates, benchmark::PriorityLevel::HIGH);
+BENCHMARK(EvictionProtection3Networks050Candidates);
+BENCHMARK(EvictionProtection3Networks100Candidates);
+BENCHMARK(EvictionProtection3Networks250Candidates);

src/bench/poly1305.cpp

@@ -41,6 +41,6 @@ static void POLY1305_1MB(benchmark::Bench& bench)
     POLY1305(bench, BUFFER_SIZE_LARGE);
 }
 
-BENCHMARK(POLY1305_64BYTES, benchmark::PriorityLevel::HIGH);
-BENCHMARK(POLY1305_256BYTES, benchmark::PriorityLevel::HIGH);
-BENCHMARK(POLY1305_1MB, benchmark::PriorityLevel::HIGH);
+BENCHMARK(POLY1305_64BYTES);
+BENCHMARK(POLY1305_256BYTES);
+BENCHMARK(POLY1305_1MB);

src/bench/pool.cpp

@@ -49,5 +49,5 @@ static void PoolAllocator_StdUnorderedMapWithPoolResource(benchmark::Bench& benc
     BenchFillClearMap(bench, map);
 }
 
-BENCHMARK(PoolAllocator_StdUnorderedMap, benchmark::PriorityLevel::HIGH);
-BENCHMARK(PoolAllocator_StdUnorderedMapWithPoolResource, benchmark::PriorityLevel::HIGH);
+BENCHMARK(PoolAllocator_StdUnorderedMap);
+BENCHMARK(PoolAllocator_StdUnorderedMapWithPoolResource);

src/bench/prevector.cpp

@@ -116,12 +116,12 @@ static void PrevectorFillVectorIndirect(benchmark::Bench& bench)
     {                                                                \
         Prevector##name<nontrivial_t>(bench);                        \
     }                                                                \
-    BENCHMARK(Prevector##name##Nontrivial, benchmark::PriorityLevel::HIGH);         \
+    BENCHMARK(Prevector##name##Nontrivial);         \
     static void Prevector##name##Trivial(benchmark::Bench& bench)    \
     {                                                                \
         Prevector##name<trivial_t>(bench);                           \
     }                                                                \
-    BENCHMARK(Prevector##name##Trivial, benchmark::PriorityLevel::HIGH);
+    BENCHMARK(Prevector##name##Trivial);
 
 PREVECTOR_TEST(Clear)
 PREVECTOR_TEST(Destructor)

src/bench/random.cpp

@@ -86,20 +86,20 @@ void InsecureRandom_stdshuffle100(benchmark::Bench& bench) { BenchRandom_stdshuf
 
 } // namespace
 
-BENCHMARK(FastRandom_rand64, benchmark::PriorityLevel::HIGH);
-BENCHMARK(FastRandom_rand32, benchmark::PriorityLevel::HIGH);
-BENCHMARK(FastRandom_randbool, benchmark::PriorityLevel::HIGH);
-BENCHMARK(FastRandom_randbits, benchmark::PriorityLevel::HIGH);
-BENCHMARK(FastRandom_randrange100, benchmark::PriorityLevel::HIGH);
-BENCHMARK(FastRandom_randrange1000, benchmark::PriorityLevel::HIGH);
-BENCHMARK(FastRandom_randrange1000000, benchmark::PriorityLevel::HIGH);
-BENCHMARK(FastRandom_stdshuffle100, benchmark::PriorityLevel::HIGH);
+BENCHMARK(FastRandom_rand64);
+BENCHMARK(FastRandom_rand32);
+BENCHMARK(FastRandom_randbool);
+BENCHMARK(FastRandom_randbits);
+BENCHMARK(FastRandom_randrange100);
+BENCHMARK(FastRandom_randrange1000);
+BENCHMARK(FastRandom_randrange1000000);
+BENCHMARK(FastRandom_stdshuffle100);
 
-BENCHMARK(InsecureRandom_rand64, benchmark::PriorityLevel::HIGH);
-BENCHMARK(InsecureRandom_rand32, benchmark::PriorityLevel::HIGH);
-BENCHMARK(InsecureRandom_randbool, benchmark::PriorityLevel::HIGH);
-BENCHMARK(InsecureRandom_randbits, benchmark::PriorityLevel::HIGH);
-BENCHMARK(InsecureRandom_randrange100, benchmark::PriorityLevel::HIGH);
-BENCHMARK(InsecureRandom_randrange1000, benchmark::PriorityLevel::HIGH);
-BENCHMARK(InsecureRandom_randrange1000000, benchmark::PriorityLevel::HIGH);
-BENCHMARK(InsecureRandom_stdshuffle100, benchmark::PriorityLevel::HIGH);
+BENCHMARK(InsecureRandom_rand64);
+BENCHMARK(InsecureRandom_rand32);
+BENCHMARK(InsecureRandom_randbool);
+BENCHMARK(InsecureRandom_randbits);
+BENCHMARK(InsecureRandom_randrange100);
+BENCHMARK(InsecureRandom_randrange1000);
+BENCHMARK(InsecureRandom_randrange1000000);
+BENCHMARK(InsecureRandom_stdshuffle100);

src/bench/readwriteblock.cpp

@@ -63,6 +63,6 @@ static void ReadRawBlockBench(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(WriteBlockBench, benchmark::PriorityLevel::HIGH);
-BENCHMARK(ReadBlockBench, benchmark::PriorityLevel::HIGH);
-BENCHMARK(ReadRawBlockBench, benchmark::PriorityLevel::HIGH);
+BENCHMARK(WriteBlockBench);
+BENCHMARK(ReadBlockBench);
+BENCHMARK(ReadRawBlockBench);

src/bench/rollingbloom.cpp

@@ -34,5 +34,5 @@ static void RollingBloomReset(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(RollingBloom, benchmark::PriorityLevel::HIGH);
-BENCHMARK(RollingBloomReset, benchmark::PriorityLevel::HIGH);
+BENCHMARK(RollingBloom);
+BENCHMARK(RollingBloomReset);

src/bench/rpc_blockchain.cpp

@@ -70,9 +70,9 @@ static void BlockToJsonVerbosity3(benchmark::Bench& bench)
     BlockToJson(bench, TxVerbosity::SHOW_DETAILS_AND_PREVOUT);
 }
 
-BENCHMARK(BlockToJsonVerbosity1, benchmark::PriorityLevel::HIGH);
-BENCHMARK(BlockToJsonVerbosity2, benchmark::PriorityLevel::HIGH);
-BENCHMARK(BlockToJsonVerbosity3, benchmark::PriorityLevel::HIGH);
+BENCHMARK(BlockToJsonVerbosity1);
+BENCHMARK(BlockToJsonVerbosity2);
+BENCHMARK(BlockToJsonVerbosity3);
 
 static void BlockToJsonVerboseWrite(benchmark::Bench& bench)
 {
@@ -85,4 +85,4 @@ static void BlockToJsonVerboseWrite(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(BlockToJsonVerboseWrite, benchmark::PriorityLevel::HIGH);
+BENCHMARK(BlockToJsonVerboseWrite);

src/bench/rpc_mempool.cpp

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

src/bench/sign_transaction.cpp

@@ -100,7 +100,7 @@ static void SignSchnorrWithNullMerkleRoot(benchmark::Bench& bench)
     SignSchnorrTapTweakBenchmark(bench, /*use_null_merkle_root=*/true);
 }
 
-BENCHMARK(SignTransactionECDSA, benchmark::PriorityLevel::HIGH);
-BENCHMARK(SignTransactionSchnorr, benchmark::PriorityLevel::HIGH);
-BENCHMARK(SignSchnorrWithMerkleRoot, benchmark::PriorityLevel::HIGH);
-BENCHMARK(SignSchnorrWithNullMerkleRoot, benchmark::PriorityLevel::HIGH);
+BENCHMARK(SignTransactionECDSA);
+BENCHMARK(SignTransactionSchnorr);
+BENCHMARK(SignSchnorrWithMerkleRoot);
+BENCHMARK(SignSchnorrWithNullMerkleRoot);

src/bench/streams_findbyte.cpp

@@ -30,4 +30,4 @@ static void FindByte(benchmark::Bench& bench)
     assert(file.fclose() == 0);
 }
 
-BENCHMARK(FindByte, benchmark::PriorityLevel::HIGH);
+BENCHMARK(FindByte);

src/bench/strencodings.cpp

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

src/bench/txgraph.cpp

@@ -123,4 +123,4 @@ void BenchTxGraphTrim(benchmark::Bench& bench)
 
 static void TxGraphTrim(benchmark::Bench& bench) { BenchTxGraphTrim(bench); }
 
-BENCHMARK(TxGraphTrim, benchmark::PriorityLevel::HIGH);
+BENCHMARK(TxGraphTrim);

src/bench/txorphanage.cpp

@@ -262,7 +262,7 @@ static void OrphanageEraseForPeer(benchmark::Bench& bench)
     OrphanageEraseAll(bench, /*block_or_disconnect=*/false);
 }
 
-BENCHMARK(OrphanageSinglePeerEviction, benchmark::PriorityLevel::LOW);
-BENCHMARK(OrphanageMultiPeerEviction, benchmark::PriorityLevel::LOW);
-BENCHMARK(OrphanageEraseForBlock, benchmark::PriorityLevel::LOW);
-BENCHMARK(OrphanageEraseForPeer, benchmark::PriorityLevel::LOW);
+BENCHMARK(OrphanageSinglePeerEviction);
+BENCHMARK(OrphanageMultiPeerEviction);
+BENCHMARK(OrphanageEraseForBlock);
+BENCHMARK(OrphanageEraseForPeer);

src/bench/util_time.cpp

@@ -36,7 +36,7 @@ static void BenchTimeMillisSys(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(BenchTimeDeprecated, benchmark::PriorityLevel::HIGH);
-BENCHMARK(BenchTimeMillis, benchmark::PriorityLevel::HIGH);
-BENCHMARK(BenchTimeMillisSys, benchmark::PriorityLevel::HIGH);
-BENCHMARK(BenchTimeMock, benchmark::PriorityLevel::HIGH);
+BENCHMARK(BenchTimeDeprecated);
+BENCHMARK(BenchTimeMillis);
+BENCHMARK(BenchTimeMillisSys);
+BENCHMARK(BenchTimeMock);

src/bench/verify_script.cpp

@@ -87,5 +87,5 @@ static void VerifyNestedIfScript(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(VerifyScriptBench, benchmark::PriorityLevel::HIGH);
-BENCHMARK(VerifyNestedIfScript, benchmark::PriorityLevel::HIGH);
+BENCHMARK(VerifyScriptBench);
+BENCHMARK(VerifyNestedIfScript);

src/bench/wallet_balance.cpp

@@ -64,8 +64,8 @@ static void WalletBalanceClean(benchmark::Bench& bench) { WalletBalance(bench, /
 static void WalletBalanceMine(benchmark::Bench& bench) { WalletBalance(bench, /*set_dirty=*/false, /*add_mine=*/true); }
 static void WalletBalanceWatch(benchmark::Bench& bench) { WalletBalance(bench, /*set_dirty=*/false, /*add_mine=*/false); }
 
-BENCHMARK(WalletBalanceDirty, benchmark::PriorityLevel::HIGH);
-BENCHMARK(WalletBalanceClean, benchmark::PriorityLevel::HIGH);
-BENCHMARK(WalletBalanceMine, benchmark::PriorityLevel::HIGH);
-BENCHMARK(WalletBalanceWatch, benchmark::PriorityLevel::HIGH);
+BENCHMARK(WalletBalanceDirty);
+BENCHMARK(WalletBalanceClean);
+BENCHMARK(WalletBalanceMine);
+BENCHMARK(WalletBalanceWatch);
 } // namespace wallet

src/bench/wallet_create.cpp

@@ -60,7 +60,7 @@ static void WalletCreate(benchmark::Bench& bench, bool encrypted)
 static void WalletCreatePlain(benchmark::Bench& bench) { WalletCreate(bench, /*encrypted=*/false); }
 static void WalletCreateEncrypted(benchmark::Bench& bench) { WalletCreate(bench, /*encrypted=*/true); }
 
-BENCHMARK(WalletCreatePlain, benchmark::PriorityLevel::LOW);
-BENCHMARK(WalletCreateEncrypted, benchmark::PriorityLevel::LOW);
+BENCHMARK(WalletCreatePlain);
+BENCHMARK(WalletCreateEncrypted);
 
 } // namespace wallet

src/bench/wallet_create_tx.cpp

@@ -215,6 +215,6 @@ static void WalletCreateTxUsePresetInputsAndCoinSelection(benchmark::Bench& benc
 
 static void WalletAvailableCoins(benchmark::Bench& bench) { AvailableCoins(bench, {OutputType::BECH32M}); }
 
-BENCHMARK(WalletCreateTxUseOnlyPresetInputs, benchmark::PriorityLevel::LOW)
-BENCHMARK(WalletCreateTxUsePresetInputsAndCoinSelection, benchmark::PriorityLevel::LOW)
-BENCHMARK(WalletAvailableCoins, benchmark::PriorityLevel::LOW);
+BENCHMARK(WalletCreateTxUseOnlyPresetInputs)
+BENCHMARK(WalletCreateTxUsePresetInputsAndCoinSelection)
+BENCHMARK(WalletAvailableCoins);

src/bench/wallet_ismine.cpp

@@ -66,6 +66,6 @@ static void WalletIsMine(benchmark::Bench& bench, int num_combo = 0)
 
 static void WalletIsMineDescriptors(benchmark::Bench& bench) { WalletIsMine(bench); }
 static void WalletIsMineMigratedDescriptors(benchmark::Bench& bench) { WalletIsMine(bench, /*num_combo=*/2000); }
-BENCHMARK(WalletIsMineDescriptors, benchmark::PriorityLevel::LOW);
-BENCHMARK(WalletIsMineMigratedDescriptors, benchmark::PriorityLevel::LOW);
+BENCHMARK(WalletIsMineDescriptors);
+BENCHMARK(WalletIsMineMigratedDescriptors);
 } // namespace wallet

src/bench/wallet_loading.cpp

@@ -64,5 +64,5 @@ static void WalletLoadingDescriptors(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(WalletLoadingDescriptors, benchmark::PriorityLevel::HIGH);
+BENCHMARK(WalletLoadingDescriptors);
 } // namespace wallet

src/bench/wallet_migration.cpp

@@ -74,6 +74,6 @@ static void WalletMigration(benchmark::Bench& bench)
          });
 }
 
-BENCHMARK(WalletMigration, benchmark::PriorityLevel::LOW);
+BENCHMARK(WalletMigration);
 
 } // namespace wallet