bench-chain.c (8666B)
1 #include <stdint.h> 2 #include <stdio.h> 3 #include <stdlib.h> 4 #include <string.h> 5 #include <time.h> 6 7 #include "keccak-fast-internal.h" 8 #include "src/sfinx.c" 9 10 static kf_hash_fn orig_one[4]; 11 12 #define KF_CHAIN_PROTO(name) \ 13 void name(size_t, uint8_t *, size_t, const uint8_t *, size_t, size_t, uint8_t, uint32_t, size_t, uint8_t) 14 #define KF_HASH_PROTO(name) int name(uint8_t *, size_t, const uint8_t *, size_t) 15 16 KF_CHAIN_PROTO(kf_scalar_chain); 17 KF_CHAIN_PROTO(kf_scalar_chain12); 18 void kf_scalar_batch(uint64_t states[][25], size_t count); 19 void kf_scalar_batch12(uint64_t states[][25], size_t count); 20 KF_HASH_PROTO(kf_scalar_sha3_224); 21 KF_HASH_PROTO(kf_scalar_sha3_256); 22 KF_HASH_PROTO(kf_scalar_sha3_384); 23 KF_HASH_PROTO(kf_scalar_sha3_512); 24 25 #if (defined(__x86_64__) || defined(_M_X64) || defined(__i386__)) && !defined(KECCAK_FAST_NO_BMI) 26 KF_CHAIN_PROTO(kf_bmi_chain); 27 KF_CHAIN_PROTO(kf_bmi_chain12); 28 void kf_bmi_batch(uint64_t states[][25], size_t count); 29 void kf_bmi_batch12(uint64_t states[][25], size_t count); 30 KF_HASH_PROTO(kf_bmi_sha3_224); 31 KF_HASH_PROTO(kf_bmi_sha3_256); 32 KF_HASH_PROTO(kf_bmi_sha3_384); 33 KF_HASH_PROTO(kf_bmi_sha3_512); 34 #endif 35 36 #if (defined(__x86_64__) || defined(_M_X64) || defined(__i386__)) && !defined(KECCAK_FAST_NO_AVX2) 37 KF_CHAIN_PROTO(kf_avx2_chain); 38 KF_CHAIN_PROTO(kf_avx2_chain12); 39 void kf_avx2_batch(uint64_t states[][25], size_t count); 40 void kf_avx2_batch12(uint64_t states[][25], size_t count); 41 #endif 42 #if (defined(__x86_64__) || defined(_M_X64) || defined(__i386__)) && !defined(KECCAK_FAST_NO_AVX512) 43 KF_CHAIN_PROTO(kf_avx512_chain); 44 KF_CHAIN_PROTO(kf_avx512_chain12); 45 void kf_avx512_batch(uint64_t states[][25], size_t count); 46 void kf_avx512_batch12(uint64_t states[][25], size_t count); 47 #endif 48 #if defined(__aarch64__) && !defined(KECCAK_FAST_NO_SHA3) 49 int kf_armsha3_available(void); 50 KF_CHAIN_PROTO(kf_armsha3_chain); 51 KF_CHAIN_PROTO(kf_armsha3_chain12); 52 void kf_armsha3_batch(uint64_t states[][25], size_t count); 53 void kf_armsha3_batch12(uint64_t states[][25], size_t count); 54 #endif 55 56 typedef struct { 57 const char *label; 58 kf_batch_perm_fn perm; 59 kf_batch_perm_fn perm12; 60 kf_chain_fn chain; 61 kf_chain_fn chain12; 62 int lanes; 63 kf_hash_fn one[4]; 64 } row; 65 66 static uint64_t now_ns(void) { 67 struct timespec ts; 68 clock_gettime(CLOCK_MONOTONIC, &ts); 69 return (uint64_t)ts.tv_sec * 1000000000ull + (uint64_t)ts.tv_nsec; 70 } 71 72 static double mhs(uint64_t ns, size_t hashes) { 73 return (double)hashes * 1000.0 / (double)ns; 74 } 75 76 static void cell(double v) { 77 if (v < 0.0) { 78 printf(" %10s", "-"); 79 } else { 80 printf(" %10.3f", v); 81 } 82 } 83 84 int main(int argc, char **argv) { 85 static const sfinx_hash hashes[] = {SFINX_HASH_224, SFINX_HASH_256, SFINX_HASH_384, SFINX_HASH_512}; 86 static const char *sizes[] = {"SHA3-224", "SHA3-256", "SHA3-384", "SHA3-512"}; 87 unsigned reps = 5; 88 row rows[5]; 89 int nr = 0; 90 91 for (int i = 1; i + 1 < argc; i += 2) { 92 if (strcmp(argv[i], "-n") == 0) { 93 reps = (unsigned)strtoul(argv[i + 1], NULL, 10); 94 } 95 } 96 if (reps == 0) { 97 reps = 1; 98 } 99 100 orig_one[0] = kf_sha3_224; 101 orig_one[1] = kf_sha3_256; 102 orig_one[2] = kf_sha3_384; 103 orig_one[3] = kf_sha3_512; 104 105 rows[nr++] = (row){"scalar", 106 kf_scalar_batch, 107 kf_scalar_batch12, 108 kf_scalar_chain, 109 kf_scalar_chain12, 110 1, 111 {kf_scalar_sha3_224, kf_scalar_sha3_256, kf_scalar_sha3_384, kf_scalar_sha3_512}}; 112 #if (defined(__x86_64__) || defined(_M_X64) || defined(__i386__)) && !defined(KECCAK_FAST_NO_BMI) 113 #if defined(__clang__) 114 if (__builtin_cpu_supports("bmi")) { 115 #else 116 if (__builtin_cpu_supports("bmi") && __builtin_cpu_supports("bmi2")) { 117 #endif 118 rows[nr++] = (row){"scalar+bmi", 119 kf_bmi_batch, 120 kf_bmi_batch12, 121 kf_bmi_chain, 122 kf_bmi_chain12, 123 1, 124 {kf_bmi_sha3_224, kf_bmi_sha3_256, kf_bmi_sha3_384, kf_bmi_sha3_512}}; 125 } 126 #endif 127 #if (defined(__x86_64__) || defined(_M_X64) || defined(__i386__)) && !defined(KECCAK_FAST_NO_AVX2) 128 if (__builtin_cpu_supports("avx2")) { 129 rows[nr++] = 130 (row){"avx2 x4", kf_avx2_batch, kf_avx2_batch12, kf_avx2_chain, kf_avx2_chain12, 4, {NULL, NULL, NULL, NULL}}; 131 } 132 #endif 133 #if (defined(__x86_64__) || defined(_M_X64) || defined(__i386__)) && !defined(KECCAK_FAST_NO_AVX512) 134 if (__builtin_cpu_supports("avx512f")) { 135 rows[nr++] = (row){"avx512 x8", kf_avx512_batch, kf_avx512_batch12, kf_avx512_chain, kf_avx512_chain12, 136 8, {NULL, NULL, NULL, NULL}}; 137 } 138 #endif 139 #if defined(__aarch64__) && !defined(KECCAK_FAST_NO_SHA3) 140 if (kf_armsha3_available()) { 141 rows[nr++] = 142 (row){"arm-sha3 x2", kf_armsha3_batch, kf_armsha3_batch12, kf_armsha3_chain, kf_armsha3_chain12, 2, 143 {NULL, NULL, NULL, NULL}}; 144 } 145 #endif 146 147 printf("sfinx WOTS chain microbenchmark\n"); 148 printf("# one subtree of chains, 256 steps, best of %u\n", reps); 149 printf("# plain: the untweaked batch loop this replaced\n"); 150 printf("# glue: the tweak over the batch API, rebuilding records each step\n"); 151 printf("# fused: the chain kernel\n\n"); 152 153 for (size_t h = 0; h < 4; h++) { 154 sfinx_hash hash = hashes[h]; 155 size_t len = sfinx_hash_len(hash); 156 size_t c = len + 2; 157 size_t k = _sfinx_kid_len(hash); 158 size_t tail_len = k + 1; 159 size_t reclen = len + k + 2; 160 size_t count = 256 * c; 161 size_t total = count * 256; 162 uint8_t *x = malloc(count * len); 163 uint8_t *seedx = malloc(count * len); 164 uint8_t *tails = malloc(count * tail_len); 165 uint8_t *recs = malloc(count * reclen); 166 uint8_t kid[SFINX_HASH_LEN_MAX]; 167 168 if (!x || !seedx || !tails || !recs) { 169 fprintf(stderr, "out of memory\n"); 170 return 1; 171 } 172 for (size_t i = 0; i < count * len; i++) { 173 seedx[i] = (uint8_t)(i * 31 + 7); 174 } 175 _sfinx_kid(hash, (const uint8_t *)"\x01\x0a", 2, kid); 176 for (size_t r = 0; r < count; r++) { 177 memcpy(tails + r * tail_len, kid, k); 178 tails[r * tail_len + k] = (uint8_t)(r % c); 179 memcpy(recs + r * reclen + len, kid, k); 180 recs[r * reclen + len + k] = (uint8_t)(r % c); 181 } 182 183 printf("%s, %zu chains x 256 steps\n", sizes[h], count); 184 printf(" %-12s %10s %10s %10s\n", "backend", "plain", "glue", "fused"); 185 printf(" %-12s %10s %10s %10s\n", "", "Mh/s", "Mh/s", "Mh/s"); 186 187 for (int i = 0; i < nr; i++) { 188 double best_plain = -1.0, best_glue = -1.0, best_fused = -1.0; 189 190 kf_batch_perm = rows[i].perm; 191 kf_batch_perm12 = rows[i].perm12; 192 kf_batch_lanes = rows[i].lanes; 193 kf_chain_kernel = rows[i].chain; 194 kf_chain_kernel12 = rows[i].chain12; 195 kf_chain_lanes = rows[i].lanes; 196 kf_sha3_224 = orig_one[0]; 197 kf_sha3_256 = orig_one[1]; 198 kf_sha3_384 = orig_one[2]; 199 kf_sha3_512 = orig_one[3]; 200 if (rows[i].one[0] != NULL) { 201 kf_sha3_224 = rows[i].one[0]; 202 kf_sha3_256 = rows[i].one[1]; 203 kf_sha3_384 = rows[i].one[2]; 204 kf_sha3_512 = rows[i].one[3]; 205 } 206 207 for (unsigned rep = 0; rep < reps; rep++) { 208 uint64_t t0; 209 double dt; 210 211 memcpy(x, seedx, count * len); 212 t0 = now_ns(); 213 for (uint32_t step = 0; step < 256u; step++) { 214 _sfinx_hash_batch(hash, count, x, len, x, len); 215 } 216 dt = mhs(now_ns() - t0, total); 217 if (best_plain < 0.0 || dt > best_plain) best_plain = dt; 218 219 memcpy(x, seedx, count * len); 220 t0 = now_ns(); 221 for (uint32_t step = 0; step < 256u; step++) { 222 for (size_t r = 0; r < count; r++) { 223 memcpy(recs + r * reclen, x + r * len, len); 224 recs[r * reclen + len + k + 1] = (uint8_t)step; 225 } 226 _sfinx_hash_batch(hash, count, recs, reclen, x, len); 227 } 228 dt = mhs(now_ns() - t0, total); 229 if (best_glue < 0.0 || dt > best_glue) best_glue = dt; 230 231 memcpy(x, seedx, count * len); 232 t0 = now_ns(); 233 _sfinx_chain_batch(hash, count, x, tails, tail_len, 0, 256); 234 dt = mhs(now_ns() - t0, total); 235 if (best_fused < 0.0 || dt > best_fused) best_fused = dt; 236 } 237 238 printf(" %-12s", rows[i].label); 239 cell(best_plain); 240 cell(best_glue); 241 cell(best_fused); 242 printf("\n"); 243 } 244 printf("\n"); 245 246 free(x); 247 free(seedx); 248 free(tails); 249 free(recs); 250 } 251 252 return 0; 253 }