testing..

Author: furszy

src/bench/bench.cpp

@@ -73,6 +73,7 @@ namespace benchmark {
 std::map<std::string, uint8_t> map_label_priority = {
     {"high", PriorityLevel::HIGH},
     {"low", PriorityLevel::LOW},
+    {"special", PriorityLevel::SPECIAL},
     {"all", 0xff}
 };
 

src/bench/bench.h

@@ -46,6 +46,7 @@ enum PriorityLevel : uint8_t
 {
     LOW = 1 << 0,
     HIGH = 1 << 2,
+    SPECIAL = 1 << 4,
 };
 
 // List priority labels, comma-separated and sorted by increasing priority

src/bench/verify_script.cpp

@@ -22,7 +22,7 @@
 // modified to measure performance of other types of scripts.
 static void VerifyScriptBench(benchmark::Bench& bench)
 {
-    ECC_Context ecc_context{};
+    ECC_Context ecc_context{/*use_new_sign=*/false};
 
     const script_verify_flags flags{SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH};
     const int witnessversion = 0;
@@ -66,6 +66,55 @@ static void VerifyScriptBench(benchmark::Bench& bench)
     });
 }
 
+// Microbenchmark for verification of a basic P2WPKH script. Can be easily
+// modified to measure performance of other types of scripts.
+static void VerifyScriptBenchNew(benchmark::Bench& bench)
+{
+    SHA256AutoDetect(sha256_implementation::USE_SSE4_AND_SHANI);
+    ECC_Context ecc_context{/*use_new_sign=*/true};
+
+    const script_verify_flags flags{SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH};
+    const int witnessversion = 0;
+
+    // Key pair.
+    CKey key;
+    static const std::array<unsigned char, 32> vchKey = {
+            {
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1
+            }
+    };
+    key.Set(vchKey.begin(), vchKey.end(), false);
+    CPubKey pubkey = key.GetPubKey();
+    uint160 pubkeyHash;
+    CHash160().Write(pubkey).Finalize(pubkeyHash);
+
+    // Script.
+    CScript scriptPubKey = CScript() << witnessversion << ToByteVector(pubkeyHash);
+    CScript scriptSig;
+    CScript witScriptPubkey = CScript() << OP_DUP << OP_HASH160 << ToByteVector(pubkeyHash) << OP_EQUALVERIFY << OP_CHECKSIG;
+    const CMutableTransaction& txCredit = BuildCreditingTransaction(scriptPubKey, 1);
+    CMutableTransaction txSpend = BuildSpendingTransaction(scriptSig, CScriptWitness(), CTransaction(txCredit));
+    CScriptWitness& witness = txSpend.vin[0].scriptWitness;
+    witness.stack.emplace_back();
+    key.Sign(SignatureHash(witScriptPubkey, txSpend, 0, SIGHASH_ALL, txCredit.vout[0].nValue, SigVersion::WITNESS_V0), witness.stack.back());
+    witness.stack.back().push_back(static_cast<unsigned char>(SIGHASH_ALL));
+    witness.stack.push_back(ToByteVector(pubkey));
+
+    // Benchmark.
+    bench.run([&] {
+        ScriptError err;
+        bool success = VerifyScript(
+                txSpend.vin[0].scriptSig,
+                txCredit.vout[0].scriptPubKey,
+                &txSpend.vin[0].scriptWitness,
+                flags,
+                MutableTransactionSignatureChecker(&txSpend, 0, txCredit.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL),
+                &err);
+        assert(err == SCRIPT_ERR_OK);
+        assert(success);
+    });
+}
+
 static void VerifyNestedIfScript(benchmark::Bench& bench)
 {
     std::vector<std::vector<unsigned char>> stack;
@@ -87,5 +136,6 @@ static void VerifyNestedIfScript(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(VerifyScriptBench, benchmark::PriorityLevel::HIGH);
-BENCHMARK(VerifyNestedIfScript, benchmark::PriorityLevel::HIGH);
+BENCHMARK(VerifyScriptBench, benchmark::PriorityLevel::SPECIAL);
+BENCHMARK(VerifyScriptBenchNew, benchmark::PriorityLevel::SPECIAL);
+// BENCHMARK(VerifyNestedIfScript, benchmark::PriorityLevel::HIGH);

src/crypto/sha256.cpp

@@ -698,7 +698,7 @@ CSHA256::CSHA256()
 CSHA256& CSHA256::Write(const unsigned char* data, size_t len)
 {
     const unsigned char* end = data + len;
-    size_t bufsize = bytes % 64;
+    size_t bufsize = bytes & 0x3F;
     if (bufsize && bufsize + len >= 64) {
         // Fill the buffer, and process it.
         memcpy(buf + bufsize, data, 64 - bufsize);

src/key.cpp

@@ -569,7 +569,7 @@ bool ECC_InitSanityCheck() {
 }
 
 /** Initialize the elliptic curve support. May not be called twice without calling ECC_Stop first. */
-static void ECC_Start() {
+static void ECC_Start(bool use_new_sign = false) {
     assert(secp256k1_context_sign == nullptr);
 
     secp256k1_context *ctx = secp256k1_context_create(SECP256K1_CONTEXT_NONE);
@@ -583,7 +583,7 @@ static void ECC_Start() {
         assert(ret);
     }
 
-    secp256k1_set_sha256_transform_callback(GetSha256TransformFn());
+    if (use_new_sign) secp256k1_set_sha256_transform_callback(GetSha256TransformFn());
     secp256k1_context_sign = ctx;
 }
 
@@ -597,9 +597,9 @@ static void ECC_Stop() {
     }
 }
 
-ECC_Context::ECC_Context()
+ECC_Context::ECC_Context(bool use_new_sign)
 {
-    ECC_Start();
+    ECC_Start(use_new_sign);
 }
 
 ECC_Context::~ECC_Context()

src/key.h

@@ -325,7 +325,7 @@ bool ECC_InitSanityCheck();
 class ECC_Context
 {
 public:
-    ECC_Context();
+    ECC_Context(bool use_new_sign = false);
     ~ECC_Context();
 };