src/bench/crypto_hash.cpp

   1 // Copyright (c) 2016 The Bitcoin Core developers
   2 // Distributed under the MIT software license, see the accompanying
   3 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   4
   5 #include <iostream>
   6
   7 #include "bench.h"
   8 #include "bloom.h"
   9 #include "hash.h"
  10 #include "random.h"
  11 #include "uint256.h"
  12 #include "utiltime.h"
  13 #include "crypto/ripemd160.h"
  14 #include "crypto/sha1.h"
  15 #include "crypto/sha256.h"
  16 #include "crypto/sha512.h"
  17
  18 /* Number of bytes to hash per iteration */
  19 static const uint64_t BUFFER_SIZE = 1000*1000;
  20
  21 static void RIPEMD160(benchmark::State& state)
  22 {
  23     uint8_t hash[CRIPEMD160::OUTPUT_SIZE];
  24     std::vector<uint8_t> in(BUFFER_SIZE,0);
  25     while (state.KeepRunning())
  26         CRIPEMD160().Write(in.data(), in.size()).Finalize(hash);
  27 }
  28
  29 static void SHA1(benchmark::State& state)
  30 {
  31     uint8_t hash[CSHA1::OUTPUT_SIZE];
  32     std::vector<uint8_t> in(BUFFER_SIZE,0);
  33     while (state.KeepRunning())
  34         CSHA1().Write(in.data(), in.size()).Finalize(hash);
  35 }
  36
  37 static void SHA256(benchmark::State& state)
  38 {
  39     uint8_t hash[CSHA256::OUTPUT_SIZE];
  40     std::vector<uint8_t> in(BUFFER_SIZE,0);
  41     while (state.KeepRunning())
  42         CSHA256().Write(in.data(), in.size()).Finalize(hash);
  43 }
  44
  45 static void SHA256_32b(benchmark::State& state)
  46 {
  47     std::vector<uint8_t> in(32,0);
  48     while (state.KeepRunning()) {
  49         for (int i = 0; i < 1000000; i++) {
  50             CSHA256().Write(in.data(), in.size()).Finalize(in.data());
  51         }
  52     }
  53 }
  54
  55 static void SHA512(benchmark::State& state)
  56 {
  57     uint8_t hash[CSHA512::OUTPUT_SIZE];
  58     std::vector<uint8_t> in(BUFFER_SIZE,0);
  59     while (state.KeepRunning())
  60         CSHA512().Write(in.data(), in.size()).Finalize(hash);
  61 }
  62
  63 static void SipHash_32b(benchmark::State& state)
  64 {
  65     uint256 x;
  66     while (state.KeepRunning()) {
  67         for (int i = 0; i < 1000000; i++) {
  68             *((uint64_t*)x.begin()) = SipHashUint256(0, i, x);
  69         }
  70     }
  71 }
  72
  73 static void FastRandom_32bit(benchmark::State& state)
  74 {
  75     FastRandomContext rng(true);
  76     uint32_t x = 0;
  77     while (state.KeepRunning()) {
  78         for (int i = 0; i < 1000000; i++) {
  79             x += rng.rand32();
  80         }
  81     }
  82 }
  83
  84 static void FastRandom_1bit(benchmark::State& state)
  85 {
  86     FastRandomContext rng(true);
  87     uint32_t x = 0;
  88     while (state.KeepRunning()) {
  89         for (int i = 0; i < 1000000; i++) {
  90             x += rng.randbool();
  91         }
  92     }
  93 }
  94
  95 BENCHMARK(RIPEMD160);
  96 BENCHMARK(SHA1);
  97 BENCHMARK(SHA256);
  98 BENCHMARK(SHA512);
  99
 100 BENCHMARK(SHA256_32b);
 101 BENCHMARK(SipHash_32b);
 102 BENCHMARK(FastRandom_32bit);
 103 BENCHMARK(FastRandom_1bit);