Skip to content

Commit c8f0d54

Browse files
kwvgkwvg
committed
chore: move Dash-specific tests downward, sort like upstream
Also drops code comments not present upstream due to change in sorting Review with `git log -p -n1 --color-moved=dimmed_zebra`.
1 parent fda951f commit c8f0d54

File tree

1 file changed

+113
-121
lines changed

1 file changed

+113
-121
lines changed

‎src/bench/crypto_hash.cpp‎

Lines changed: 113 additions & 121 deletions
Original file line numberDiff line numberDiff line change
@@ -20,8 +20,6 @@
2020
/* Number of bytes to hash per iteration */
2121
static const uint64_t BUFFER_SIZE = 1000*1000;
2222

23-
/* Hash BUFFER_SIZE bytes via different algos */
24-
2523
static void HASH_1MB_RIPEMD160(benchmark::Bench& bench)
2624
{
2725
uint8_t hash[CRIPEMD160::OUTPUT_SIZE];
@@ -49,12 +47,30 @@ static void HASH_1MB_SHA256(benchmark::Bench& bench)
4947
});
5048
}
5149

52-
static void HASH_1MB_DSHA256(benchmark::Bench& bench)
50+
static void HASH_1MB_SHA3_256(benchmark::Bench& bench)
5351
{
54-
uint8_t hash[CSHA256::OUTPUT_SIZE];
52+
uint8_t hash[SHA3_256::OUTPUT_SIZE];
5553
std::vector<uint8_t> in(BUFFER_SIZE,0);
5654
bench.batch(in.size()).unit("byte").minEpochIterations(10).run([&] {
57-
CHash256().Write(in).Finalize(hash);
55+
SHA3_256().Write(in).Finalize(hash);
56+
});
57+
}
58+
59+
static void HASH_SHA256_32b(benchmark::Bench& bench)
60+
{
61+
std::vector<uint8_t> in(32,0);
62+
bench.run([&] {
63+
CSHA256()
64+
.Write(in.data(), in.size())
65+
.Finalize(in.data());
66+
});
67+
}
68+
69+
static void HASH_SHA256D64_1024(benchmark::Bench& bench)
70+
{
71+
std::vector<uint8_t> in(64 * 1024, 0);
72+
bench.minEpochIterations(1000).run([&] {
73+
SHA256D64(in.data(), in.data(), 1024);
5874
});
5975
}
6076

@@ -67,12 +83,100 @@ static void HASH_1MB_SHA512(benchmark::Bench& bench)
6783
});
6884
}
6985

70-
static void HASH_1MB_SHA3_256(benchmark::Bench& bench)
86+
static void HASH_SipHash_32b(benchmark::Bench& bench)
7187
{
72-
uint8_t hash[SHA3_256::OUTPUT_SIZE];
88+
uint256 x;
89+
uint64_t k1 = 0;
90+
bench.run([&] {
91+
*((uint64_t*)x.begin()) = SipHashUint256(0, ++k1, x);
92+
});
93+
}
94+
95+
static void FastRandom_32bit(benchmark::Bench& bench)
96+
{
97+
FastRandomContext rng(true);
98+
bench.run([&] {
99+
rng.rand32();
100+
});
101+
}
102+
103+
static void FastRandom_1bit(benchmark::Bench& bench)
104+
{
105+
FastRandomContext rng(true);
106+
bench.run([&] {
107+
rng.randbool();
108+
});
109+
}
110+
111+
static void MuHash(benchmark::Bench& bench)
112+
{
113+
MuHash3072 acc;
114+
unsigned char key[32] = {0};
115+
uint32_t i = 0;
116+
bench.run([&] {
117+
key[0] = ++i & 0xFF;
118+
acc *= MuHash3072(key);
119+
});
120+
}
121+
122+
static void MuHashMul(benchmark::Bench& bench)
123+
{
124+
MuHash3072 acc;
125+
FastRandomContext rng(true);
126+
MuHash3072 muhash{rng.randbytes(32)};
127+
128+
bench.run([&] {
129+
acc *= muhash;
130+
});
131+
}
132+
133+
static void MuHashDiv(benchmark::Bench& bench)
134+
{
135+
MuHash3072 acc;
136+
FastRandomContext rng(true);
137+
MuHash3072 muhash{rng.randbytes(32)};
138+
139+
bench.run([&] {
140+
acc /= muhash;
141+
});
142+
}
143+
144+
static void MuHashPrecompute(benchmark::Bench& bench)
145+
{
146+
MuHash3072 acc;
147+
FastRandomContext rng(true);
148+
std::vector<unsigned char> key{rng.randbytes(32)};
149+
150+
bench.run([&] {
151+
MuHash3072{key};
152+
});
153+
}
154+
155+
BENCHMARK(HASH_1MB_RIPEMD160);
156+
BENCHMARK(HASH_1MB_SHA1);
157+
BENCHMARK(HASH_1MB_SHA256);
158+
BENCHMARK(HASH_1MB_SHA512);
159+
BENCHMARK(HASH_1MB_SHA3_256);
160+
161+
BENCHMARK(HASH_SHA256_32b);
162+
BENCHMARK(HASH_SipHash_32b);
163+
BENCHMARK(HASH_SHA256D64_1024);
164+
BENCHMARK(FastRandom_32bit);
165+
BENCHMARK(FastRandom_1bit);
166+
167+
BENCHMARK(MuHash);
168+
BENCHMARK(MuHashMul);
169+
BENCHMARK(MuHashDiv);
170+
BENCHMARK(MuHashPrecompute);
171+
172+
/* --------------------------- Dash-specific tests start here --------------------------- */
173+
174+
static void HASH_1MB_DSHA256(benchmark::Bench& bench)
175+
{
176+
uint8_t hash[CSHA256::OUTPUT_SIZE];
73177
std::vector<uint8_t> in(BUFFER_SIZE,0);
74178
bench.batch(in.size()).unit("byte").minEpochIterations(10).run([&] {
75-
SHA3_256().Write(in).Finalize(hash);
179+
CHash256().Write(in).Finalize(hash);
76180
});
77181
}
78182

@@ -86,7 +190,6 @@ static void HASH_1MB_X11(benchmark::Bench& bench)
86190
}
87191

88192
/* Hash different number of bytes via DSHA256 */
89-
90193
static void HASH_DSHA256_0032b_single(benchmark::Bench& bench)
91194
{
92195
uint8_t hash[CSHA256::OUTPUT_SIZE];
@@ -142,7 +245,6 @@ static void HASH_DSHA256_2048b_single(benchmark::Bench& bench)
142245
}
143246

144247
/* Hash different number of bytes via X11 */
145-
146248
static void HASH_X11_0032b_single(benchmark::Bench& bench)
147249
{
148250
uint256 hash;
@@ -197,105 +299,7 @@ static void HASH_X11_2048b_single(benchmark::Bench& bench)
197299
});
198300
}
199301

200-
/* Hash 32 bytes via SHA and SipHash */
201-
202-
static void HASH_SHA256_32b(benchmark::Bench& bench)
203-
{
204-
std::vector<uint8_t> in(32,0);
205-
bench.run([&] {
206-
CSHA256()
207-
.Write(in.data(), in.size())
208-
.Finalize(in.data());
209-
});
210-
}
211-
212-
static void HASH_SipHash_32b(benchmark::Bench& bench)
213-
{
214-
uint256 x;
215-
uint64_t k1 = 0;
216-
bench.run([&] {
217-
*((uint64_t*)x.begin()) = SipHashUint256(0, ++k1, x);
218-
});
219-
}
220-
221-
/* Hash 1024 blobs 64 bytes each via DSHA256 */
222-
223-
static void HASH_SHA256D64_1024(benchmark::Bench& bench)
224-
{
225-
std::vector<uint8_t> in(64 * 1024, 0);
226-
bench.minEpochIterations(1000).run([&] {
227-
SHA256D64(in.data(), in.data(), 1024);
228-
});
229-
}
230-
231-
/* FastRandom for uint32_t and bool */
232-
233-
static void FastRandom_32bit(benchmark::Bench& bench)
234-
{
235-
FastRandomContext rng(true);
236-
bench.run([&] {
237-
rng.rand32();
238-
});
239-
}
240-
241-
static void FastRandom_1bit(benchmark::Bench& bench)
242-
{
243-
FastRandomContext rng(true);
244-
bench.run([&] {
245-
rng.randbool();
246-
});
247-
}
248-
249-
static void MuHash(benchmark::Bench& bench)
250-
{
251-
MuHash3072 acc;
252-
unsigned char key[32] = {0};
253-
uint32_t i = 0;
254-
bench.run([&] {
255-
key[0] = ++i & 0xFF;
256-
acc *= MuHash3072(key);
257-
});
258-
}
259-
260-
static void MuHashMul(benchmark::Bench& bench)
261-
{
262-
MuHash3072 acc;
263-
FastRandomContext rng(true);
264-
MuHash3072 muhash{rng.randbytes(32)};
265-
266-
bench.run([&] {
267-
acc *= muhash;
268-
});
269-
}
270-
271-
static void MuHashDiv(benchmark::Bench& bench)
272-
{
273-
MuHash3072 acc;
274-
FastRandomContext rng(true);
275-
MuHash3072 muhash{rng.randbytes(32)};
276-
277-
bench.run([&] {
278-
acc /= muhash;
279-
});
280-
}
281-
282-
static void MuHashPrecompute(benchmark::Bench& bench)
283-
{
284-
MuHash3072 acc;
285-
FastRandomContext rng(true);
286-
std::vector<unsigned char> key{rng.randbytes(32)};
287-
288-
bench.run([&] {
289-
MuHash3072{key};
290-
});
291-
}
292-
293302
BENCHMARK(HASH_1MB_DSHA256);
294-
BENCHMARK(HASH_1MB_RIPEMD160);
295-
BENCHMARK(HASH_1MB_SHA1);
296-
BENCHMARK(HASH_1MB_SHA256);
297-
BENCHMARK(HASH_1MB_SHA512);
298-
BENCHMARK(HASH_1MB_SHA3_256);
299303
BENCHMARK(HASH_1MB_X11);
300304

301305
BENCHMARK(HASH_DSHA256_0032b_single);
@@ -304,22 +308,10 @@ BENCHMARK(HASH_DSHA256_0128b_single);
304308
BENCHMARK(HASH_DSHA256_0512b_single);
305309
BENCHMARK(HASH_DSHA256_1024b_single);
306310
BENCHMARK(HASH_DSHA256_2048b_single);
311+
307312
BENCHMARK(HASH_X11_0032b_single);
308313
BENCHMARK(HASH_X11_0080b_single);
309314
BENCHMARK(HASH_X11_0128b_single);
310315
BENCHMARK(HASH_X11_0512b_single);
311316
BENCHMARK(HASH_X11_1024b_single);
312317
BENCHMARK(HASH_X11_2048b_single);
313-
314-
BENCHMARK(HASH_SHA256_32b);
315-
BENCHMARK(HASH_SipHash_32b);
316-
317-
BENCHMARK(HASH_SHA256D64_1024);
318-
319-
BENCHMARK(FastRandom_32bit);
320-
BENCHMARK(FastRandom_1bit);
321-
322-
BENCHMARK(MuHash);
323-
BENCHMARK(MuHashMul);
324-
BENCHMARK(MuHashDiv);
325-
BENCHMARK(MuHashPrecompute);

0 commit comments

Comments
 (0)