chore: realign function names in crypto_hash bench with upstream

We'll also do the same for Dash-specific tests to adopt the same style
but this means our upstream portions now mirror 1:1.

Author: kwvg

src/bench/crypto_hash.cpp

@@ -20,7 +20,7 @@
 /* Number of bytes to hash per iteration */
 static const uint64_t BUFFER_SIZE = 1000*1000;
 
-static void HASH_1MB_RIPEMD160(benchmark::Bench& bench)
+static void BenchRIPEMD160(benchmark::Bench& bench)
 {
     uint8_t hash[CRIPEMD160::OUTPUT_SIZE];
     std::vector<uint8_t> in(BUFFER_SIZE,0);
@@ -29,7 +29,7 @@ static void HASH_1MB_RIPEMD160(benchmark::Bench& bench)
     });
 }
 
-static void HASH_1MB_SHA1(benchmark::Bench& bench)
+static void SHA1(benchmark::Bench& bench)
 {
     uint8_t hash[CSHA1::OUTPUT_SIZE];
     std::vector<uint8_t> in(BUFFER_SIZE,0);
@@ -38,7 +38,7 @@ static void HASH_1MB_SHA1(benchmark::Bench& bench)
     });
 }
 
-static void HASH_1MB_SHA256(benchmark::Bench& bench)
+static void SHA256(benchmark::Bench& bench)
 {
     uint8_t hash[CSHA256::OUTPUT_SIZE];
     std::vector<uint8_t> in(BUFFER_SIZE,0);
@@ -47,7 +47,7 @@ static void HASH_1MB_SHA256(benchmark::Bench& bench)
     });
 }
 
-static void HASH_1MB_SHA3_256(benchmark::Bench& bench)
+static void SHA3_256_1M(benchmark::Bench& bench)
 {
     uint8_t hash[SHA3_256::OUTPUT_SIZE];
     std::vector<uint8_t> in(BUFFER_SIZE,0);
@@ -56,7 +56,7 @@ static void HASH_1MB_SHA3_256(benchmark::Bench& bench)
     });
 }
 
-static void HASH_SHA256_32b(benchmark::Bench& bench)
+static void SHA256_32b(benchmark::Bench& bench)
 {
     std::vector<uint8_t> in(32,0);
     bench.batch(in.size()).unit("byte").run([&] {
@@ -66,15 +66,15 @@ static void HASH_SHA256_32b(benchmark::Bench& bench)
     });
 }
 
-static void HASH_SHA256D64_1024(benchmark::Bench& bench)
+static void SHA256D64_1024(benchmark::Bench& bench)
 {
     std::vector<uint8_t> in(64 * 1024, 0);
     bench.batch(in.size()).unit("byte").run([&] {
         SHA256D64(in.data(), in.data(), 1024);
     });
 }
 
-static void HASH_1MB_SHA512(benchmark::Bench& bench)
+static void SHA512(benchmark::Bench& bench)
 {
     uint8_t hash[CSHA512::OUTPUT_SIZE];
     std::vector<uint8_t> in(BUFFER_SIZE,0);
@@ -83,7 +83,7 @@ static void HASH_1MB_SHA512(benchmark::Bench& bench)
     });
 }
 
-static void HASH_SipHash_32b(benchmark::Bench& bench)
+static void SipHash_32b(benchmark::Bench& bench)
 {
     uint256 x;
     uint64_t k1 = 0;
@@ -152,15 +152,15 @@ static void MuHashPrecompute(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(HASH_1MB_RIPEMD160);
-BENCHMARK(HASH_1MB_SHA1);
-BENCHMARK(HASH_1MB_SHA256);
-BENCHMARK(HASH_1MB_SHA512);
-BENCHMARK(HASH_1MB_SHA3_256);
+BENCHMARK(BenchRIPEMD160);
+BENCHMARK(SHA1);
+BENCHMARK(SHA256);
+BENCHMARK(SHA512);
+BENCHMARK(SHA3_256_1M);
 
-BENCHMARK(HASH_SHA256_32b);
-BENCHMARK(HASH_SipHash_32b);
-BENCHMARK(HASH_SHA256D64_1024);
+BENCHMARK(SHA256_32b);
+BENCHMARK(SipHash_32b);
+BENCHMARK(SHA256D64_1024);
 BENCHMARK(FastRandom_32bit);
 BENCHMARK(FastRandom_1bit);
 
@@ -171,7 +171,7 @@ BENCHMARK(MuHashPrecompute);
 
 /* --------------------------- Dash-specific tests start here --------------------------- */
 
-static void HASH_1MB_DSHA256(benchmark::Bench& bench)
+static void DSHA256_1M(benchmark::Bench& bench)
 {
     uint8_t hash[CSHA256::OUTPUT_SIZE];
     std::vector<uint8_t> in(BUFFER_SIZE,0);
@@ -180,7 +180,7 @@ static void HASH_1MB_DSHA256(benchmark::Bench& bench)
     });
 }
 
-static void HASH_1MB_X11(benchmark::Bench& bench)
+static void X11_1M(benchmark::Bench& bench)
 {
     uint256 hash;
     std::vector<uint8_t> in(BUFFER_SIZE,0);
@@ -190,7 +190,7 @@ static void HASH_1MB_X11(benchmark::Bench& bench)
 }
 
 /* Hash different number of bytes via DSHA256 */
-static void HASH_DSHA256_0032b_single(benchmark::Bench& bench)
+static void DSHA256_0032b_single(benchmark::Bench& bench)
 {
     uint8_t hash[CSHA256::OUTPUT_SIZE];
     std::vector<uint8_t> in(32,0);
@@ -199,7 +199,7 @@ static void HASH_DSHA256_0032b_single(benchmark::Bench& bench)
     });
 }
 
-static void HASH_DSHA256_0080b_single(benchmark::Bench& bench)
+static void DSHA256_0080b_single(benchmark::Bench& bench)
 {
     uint8_t hash[CSHA256::OUTPUT_SIZE];
     std::vector<uint8_t> in(80,0);
@@ -208,7 +208,7 @@ static void HASH_DSHA256_0080b_single(benchmark::Bench& bench)
     });
 }
 
-static void HASH_DSHA256_0128b_single(benchmark::Bench& bench)
+static void DSHA256_0128b_single(benchmark::Bench& bench)
 {
     uint8_t hash[CSHA256::OUTPUT_SIZE];
     std::vector<uint8_t> in(128,0);
@@ -217,7 +217,7 @@ static void HASH_DSHA256_0128b_single(benchmark::Bench& bench)
     });
 }
 
-static void HASH_DSHA256_0512b_single(benchmark::Bench& bench)
+static void DSHA256_0512b_single(benchmark::Bench& bench)
 {
     uint8_t hash[CSHA256::OUTPUT_SIZE];
     std::vector<uint8_t> in(512,0);
@@ -226,7 +226,7 @@ static void HASH_DSHA256_0512b_single(benchmark::Bench& bench)
     });
 }
 
-static void HASH_DSHA256_1024b_single(benchmark::Bench& bench)
+static void DSHA256_1024b_single(benchmark::Bench& bench)
 {
     uint8_t hash[CSHA256::OUTPUT_SIZE];
     std::vector<uint8_t> in(1024,0);
@@ -235,7 +235,7 @@ static void HASH_DSHA256_1024b_single(benchmark::Bench& bench)
     });
 }
 
-static void HASH_DSHA256_2048b_single(benchmark::Bench& bench)
+static void DSHA256_2048b_single(benchmark::Bench& bench)
 {
     uint8_t hash[CSHA256::OUTPUT_SIZE];
     std::vector<uint8_t> in(2048,0);
@@ -245,7 +245,7 @@ static void HASH_DSHA256_2048b_single(benchmark::Bench& bench)
 }
 
 /* Hash different number of bytes via X11 */
-static void HASH_X11_0032b_single(benchmark::Bench& bench)
+static void X11_0032b_single(benchmark::Bench& bench)
 {
     uint256 hash;
     std::vector<uint8_t> in(32,0);
@@ -254,7 +254,7 @@ static void HASH_X11_0032b_single(benchmark::Bench& bench)
     });
 }
 
-static void HASH_X11_0080b_single(benchmark::Bench& bench)
+static void X11_0080b_single(benchmark::Bench& bench)
 {
     uint256 hash;
     std::vector<uint8_t> in(80,0);
@@ -263,7 +263,7 @@ static void HASH_X11_0080b_single(benchmark::Bench& bench)
     });
 }
 
-static void HASH_X11_0128b_single(benchmark::Bench& bench)
+static void X11_0128b_single(benchmark::Bench& bench)
 {
     uint256 hash;
     std::vector<uint8_t> in(128,0);
@@ -272,7 +272,7 @@ static void HASH_X11_0128b_single(benchmark::Bench& bench)
     });
 }
 
-static void HASH_X11_0512b_single(benchmark::Bench& bench)
+static void X11_0512b_single(benchmark::Bench& bench)
 {
     uint256 hash;
     std::vector<uint8_t> in(512,0);
@@ -281,7 +281,7 @@ static void HASH_X11_0512b_single(benchmark::Bench& bench)
     });
 }
 
-static void HASH_X11_1024b_single(benchmark::Bench& bench)
+static void X11_1024b_single(benchmark::Bench& bench)
 {
     uint256 hash;
     std::vector<uint8_t> in(1024,0);
@@ -290,7 +290,7 @@ static void HASH_X11_1024b_single(benchmark::Bench& bench)
     });
 }
 
-static void HASH_X11_2048b_single(benchmark::Bench& bench)
+static void X11_2048b_single(benchmark::Bench& bench)
 {
     uint256 hash;
     std::vector<uint8_t> in(2048,0);
@@ -299,19 +299,19 @@ static void HASH_X11_2048b_single(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(HASH_1MB_DSHA256);
-BENCHMARK(HASH_1MB_X11);
-
-BENCHMARK(HASH_DSHA256_0032b_single);
-BENCHMARK(HASH_DSHA256_0080b_single);
-BENCHMARK(HASH_DSHA256_0128b_single);
-BENCHMARK(HASH_DSHA256_0512b_single);
-BENCHMARK(HASH_DSHA256_1024b_single);
-BENCHMARK(HASH_DSHA256_2048b_single);
-
-BENCHMARK(HASH_X11_0032b_single);
-BENCHMARK(HASH_X11_0080b_single);
-BENCHMARK(HASH_X11_0128b_single);
-BENCHMARK(HASH_X11_0512b_single);
-BENCHMARK(HASH_X11_1024b_single);
-BENCHMARK(HASH_X11_2048b_single);
+BENCHMARK(DSHA256_1M);
+BENCHMARK(X11_1M);
+
+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(X11_0032b_single);
+BENCHMARK(X11_0080b_single);
+BENCHMARK(X11_0128b_single);
+BENCHMARK(X11_0512b_single);
+BENCHMARK(X11_1024b_single);
+BENCHMARK(X11_2048b_single);