Merge tag 'branch-0.13' into bugfix_gitdir

8 files changed, 389 insertions, 0 deletions

diff --git a/src/bench/.gitignore b/src/bench/.gitignore
new file mode 100644
index 0000000000..e231fe4cab
--- /dev/null
+++ b/src/bench/.gitignore
@@ -0,0 +1 @@
+bench_bitcoin
diff --git a/src/bench/Examples.cpp b/src/bench/Examples.cpp
new file mode 100644
index 0000000000..b6b020a971
--- /dev/null
+++ b/src/bench/Examples.cpp
@@ -0,0 +1,34 @@
+// Copyright (c) 2015 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "bench.h"
+#include "main.h"
+#include "utiltime.h"
+
+// Sanity test: this should loop ten times, and
+// min/max/average should be close to 100ms.
+static void Sleep100ms(benchmark::State& state)
+{
+    while (state.KeepRunning()) {
+        MilliSleep(100);
+    }
+}
+
+BENCHMARK(Sleep100ms);
+
+// Extremely fast-running benchmark:
+#include <math.h>
+
+volatile double sum = 0.0; // volatile, global so not optimized away
+
+static void Trig(benchmark::State& state)
+{
+    double d = 0.01;
+    while (state.KeepRunning()) {
+        sum += sin(d);
+        d += 0.000001;
+    }
+}
+
+BENCHMARK(Trig);
diff --git a/src/bench/base58.cpp b/src/bench/base58.cpp
new file mode 100644
index 0000000000..1279c3e7df
--- /dev/null
+++ b/src/bench/base58.cpp
@@ -0,0 +1,56 @@
+// Copyright (c) 2016 the Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "bench.h"
+
+#include "main.h"
+#include "base58.h"
+
+#include <vector>
+#include <string>
+
+
+static void Base58Encode(benchmark::State& state)
+{
+    unsigned char buff[32] = {
+        17, 79, 8, 99, 150, 189, 208, 162, 22, 23, 203, 163, 36, 58, 147,
+        227, 139, 2, 215, 100, 91, 38, 11, 141, 253, 40, 117, 21, 16, 90,
+        200, 24
+    };
+    unsigned char* b = buff;
+    while (state.KeepRunning()) {
+        EncodeBase58(b, b + 32);
+    }
+}
+
+
+static void Base58CheckEncode(benchmark::State& state)
+{
+    unsigned char buff[32] = {
+        17, 79, 8, 99, 150, 189, 208, 162, 22, 23, 203, 163, 36, 58, 147,
+        227, 139, 2, 215, 100, 91, 38, 11, 141, 253, 40, 117, 21, 16, 90,
+        200, 24
+    };
+    unsigned char* b = buff;
+    std::vector<unsigned char> vch;
+    vch.assign(b, b + 32);
+    while (state.KeepRunning()) {
+        EncodeBase58Check(vch);
+    }
+}
+
+
+static void Base58Decode(benchmark::State& state)
+{
+    const char* addr = "17VZNX1SN5NtKa8UQFxwQbFeFc3iqRYhem";
+    std::vector<unsigned char> vch;
+    while (state.KeepRunning()) {
+        DecodeBase58(addr, vch);
+    }
+}
+
+
+BENCHMARK(Base58Encode);
+BENCHMARK(Base58CheckEncode);
+BENCHMARK(Base58Decode);
diff --git a/src/bench/bench.cpp b/src/bench/bench.cpp
new file mode 100644
index 0000000000..227546a7a7
--- /dev/null
+++ b/src/bench/bench.cpp
@@ -0,0 +1,83 @@
+// Copyright (c) 2015 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "bench.h"
+
+#include <iostream>
+#include <iomanip>
+#include <sys/time.h>
+
+using namespace benchmark;
+
+std::map<std::string, BenchFunction> BenchRunner::benchmarks;
+
+static double gettimedouble(void) {
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    return tv.tv_usec * 0.000001 + tv.tv_sec;
+}
+
+BenchRunner::BenchRunner(std::string name, BenchFunction func)
+{
+    benchmarks.insert(std::make_pair(name, func));
+}
+
+void
+BenchRunner::RunAll(double elapsedTimeForOne)
+{
+    std::cout << "#Benchmark" << "," << "count" << "," << "min" << "," << "max" << "," << "average" << "\n";
+
+    for (std::map<std::string,BenchFunction>::iterator it = benchmarks.begin();
+         it != benchmarks.end(); ++it) {
+
+        State state(it->first, elapsedTimeForOne);
+        BenchFunction& func = it->second;
+        func(state);
+    }
+}
+
+bool State::KeepRunning()
+{
+    if (count & countMask) {
+      ++count;
+      return true;
+    }
+    double now;
+    if (count == 0) {
+        lastTime = beginTime = now = gettimedouble();
+    }
+    else {
+        now = gettimedouble();
+        double elapsed = now - lastTime;
+        double elapsedOne = elapsed * countMaskInv;
+        if (elapsedOne < minTime) minTime = elapsedOne;
+        if (elapsedOne > maxTime) maxTime = elapsedOne;
+        if (elapsed*128 < maxElapsed) {
+          // If the execution was much too fast (1/128th of maxElapsed), increase the count mask by 8x and restart timing.
+          // The restart avoids including the overhead of this code in the measurement.
+          countMask = ((countMask<<3)|7) & ((1LL<<60)-1);
+          countMaskInv = 1./(countMask+1);
+          count = 0;
+          minTime = std::numeric_limits<double>::max();
+          maxTime = std::numeric_limits<double>::min();
+          return true;
+        }
+        if (elapsed*16 < maxElapsed) {
+          countMask = ((countMask<<1)|1) & ((1LL<<60)-1);
+          countMaskInv = 1./(countMask+1);
+        }
+    }
+    lastTime = now;
+    ++count;
+
+    if (now - beginTime < maxElapsed) return true; // Keep going
+
+    --count;
+
+    // Output results
+    double average = (now-beginTime)/count;
+    std::cout << std::fixed << std::setprecision(15) << name << "," << count << "," << minTime << "," << maxTime << "," << average << "\n";
+
+    return false;
+}
diff --git a/src/bench/bench.h b/src/bench/bench.h
new file mode 100644
index 0000000000..f13b145aaf
--- /dev/null
+++ b/src/bench/bench.h
@@ -0,0 +1,73 @@
+// Copyright (c) 2015 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_BENCH_BENCH_H
+#define BITCOIN_BENCH_BENCH_H
+
+#include <map>
+#include <string>
+
+#include <boost/function.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/stringize.hpp>
+
+// Simple micro-benchmarking framework; API mostly matches a subset of the Google Benchmark
+// framework (see https://github.com/google/benchmark)
+// Wny not use the Google Benchmark framework? Because adding Yet Another Dependency
+// (that uses cmake as its build system and has lots of features we don't need) isn't
+// worth it.
+
+/*
+ * Usage:
+
+static void CODE_TO_TIME(benchmark::State& state)
+{
+    ... do any setup needed...
+    while (state.KeepRunning()) {
+       ... do stuff you want to time...
+    }
+    ... do any cleanup needed...
+}
+
+BENCHMARK(CODE_TO_TIME);
+
+ */
+ 
+namespace benchmark {
+
+    class State {
+        std::string name;
+        double maxElapsed;
+        double beginTime;
+        double lastTime, minTime, maxTime, countMaskInv;
+        int64_t count;
+        int64_t countMask;
+    public:
+        State(std::string _name, double _maxElapsed) : name(_name), maxElapsed(_maxElapsed), count(0) {
+            minTime = std::numeric_limits<double>::max();
+            maxTime = std::numeric_limits<double>::min();
+            countMask = 1;
+            countMaskInv = 1./(countMask + 1);
+        }
+        bool KeepRunning();
+    };
+
+    typedef boost::function<void(State&)> BenchFunction;
+
+    class BenchRunner
+    {
+        static std::map<std::string, BenchFunction> benchmarks;
+
+    public:
+        BenchRunner(std::string name, BenchFunction func);
+
+        static void RunAll(double elapsedTimeForOne=1.0);
+    };
+}
+
+// BENCHMARK(foo) expands to:  benchmark::BenchRunner bench_11foo("foo", foo);
+#define BENCHMARK(n) \
+    benchmark::BenchRunner BOOST_PP_CAT(bench_, BOOST_PP_CAT(__LINE__, n))(BOOST_PP_STRINGIZE(n), n);
+
+#endif // BITCOIN_BENCH_BENCH_H
diff --git a/src/bench/bench_bitcoin.cpp b/src/bench/bench_bitcoin.cpp
new file mode 100644
index 0000000000..db1402216d
--- /dev/null
+++ b/src/bench/bench_bitcoin.cpp
@@ -0,0 +1,21 @@
+// Copyright (c) 2015 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "bench.h"
+
+#include "key.h"
+#include "main.h"
+#include "util.h"
+
+int
+main(int argc, char** argv)
+{
+    ECC_Start();
+    SetupEnvironment();
+    fPrintToDebugLog = false; // don't want to write to debug.log file
+
+    benchmark::BenchRunner::RunAll();
+
+    ECC_Stop();
+}
diff --git a/src/bench/crypto_hash.cpp b/src/bench/crypto_hash.cpp
new file mode 100644
index 0000000000..168006154f
--- /dev/null
+++ b/src/bench/crypto_hash.cpp
@@ -0,0 +1,78 @@
+// Copyright (c) 2016 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <iostream>
+
+#include "bench.h"
+#include "bloom.h"
+#include "hash.h"
+#include "uint256.h"
+#include "utiltime.h"
+#include "crypto/ripemd160.h"
+#include "crypto/sha1.h"
+#include "crypto/sha256.h"
+#include "crypto/sha512.h"
+
+/* Number of bytes to hash per iteration */
+static const uint64_t BUFFER_SIZE = 1000*1000;
+
+static void RIPEMD160(benchmark::State& state)
+{
+    uint8_t hash[CRIPEMD160::OUTPUT_SIZE];
+    std::vector<uint8_t> in(BUFFER_SIZE,0);
+    while (state.KeepRunning())
+        CRIPEMD160().Write(begin_ptr(in), in.size()).Finalize(hash);
+}
+
+static void SHA1(benchmark::State& state)
+{
+    uint8_t hash[CSHA1::OUTPUT_SIZE];
+    std::vector<uint8_t> in(BUFFER_SIZE,0);
+    while (state.KeepRunning())
+        CSHA1().Write(begin_ptr(in), in.size()).Finalize(hash);
+}
+
+static void SHA256(benchmark::State& state)
+{
+    uint8_t hash[CSHA256::OUTPUT_SIZE];
+    std::vector<uint8_t> in(BUFFER_SIZE,0);
+    while (state.KeepRunning())
+        CSHA256().Write(begin_ptr(in), in.size()).Finalize(hash);
+}
+
+static void SHA256_32b(benchmark::State& state)
+{
+    std::vector<uint8_t> in(32,0);
+    while (state.KeepRunning()) {
+        for (int i = 0; i < 1000000; i++) {
+            CSHA256().Write(begin_ptr(in), in.size()).Finalize(&in[0]);
+        }
+    }
+}
+
+static void SHA512(benchmark::State& state)
+{
+    uint8_t hash[CSHA512::OUTPUT_SIZE];
+    std::vector<uint8_t> in(BUFFER_SIZE,0);
+    while (state.KeepRunning())
+        CSHA512().Write(begin_ptr(in), in.size()).Finalize(hash);
+}
+
+static void SipHash_32b(benchmark::State& state)
+{
+    uint256 x;
+    while (state.KeepRunning()) {
+        for (int i = 0; i < 1000000; i++) {
+            *((uint64_t*)x.begin()) = SipHashUint256(0, i, x);
+        }
+    }
+}
+
+BENCHMARK(RIPEMD160);
+BENCHMARK(SHA1);
+BENCHMARK(SHA256);
+BENCHMARK(SHA512);
+
+BENCHMARK(SHA256_32b);
+BENCHMARK(SipHash_32b);
diff --git a/src/bench/rollingbloom.cpp b/src/bench/rollingbloom.cpp
new file mode 100644
index 0000000000..73c02cf718
--- /dev/null
+++ b/src/bench/rollingbloom.cpp
@@ -0,0 +1,43 @@
+// Copyright (c) 2016 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <iostream>
+
+#include "bench.h"
+#include "bloom.h"
+#include "utiltime.h"
+
+static void RollingBloom(benchmark::State& state)
+{
+    CRollingBloomFilter filter(120000, 0.000001);
+    std::vector<unsigned char> data(32);
+    uint32_t count = 0;
+    uint32_t nEntriesPerGeneration = (120000 + 1) / 2;
+    uint32_t countnow = 0;
+    uint64_t match = 0;
+    while (state.KeepRunning()) {
+        count++;
+        data[0] = count;
+        data[1] = count >> 8;
+        data[2] = count >> 16;
+        data[3] = count >> 24;
+        if (countnow == nEntriesPerGeneration) {
+            int64_t b = GetTimeMicros();
+            filter.insert(data);
+            int64_t e = GetTimeMicros();
+            std::cout << "RollingBloom-refresh,1," << (e-b)*0.000001 << "," << (e-b)*0.000001 << "," << (e-b)*0.000001 << "\n";
+            countnow = 0;
+        } else {
+            filter.insert(data);
+        }
+        countnow++;
+        data[0] = count >> 24;
+        data[1] = count >> 16;
+        data[2] = count >> 8;
+        data[3] = count;
+        match += filter.contains(data);
+    }
+}
+
+BENCHMARK(RollingBloom);