sfinx

sphincs+ inspired signing utility
git clone git://git.finwo.net/app/sfinx
Log | Files | Refs | README | LICENSE

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 }