[Mining] Reduce lock contention with SHA256D

Increases the number of hashes a SHA256D miner thread attempts
per created block template, and adds a separate counter to allow
an early continuation when the chain tip changes.

The SHA256D algorithm is fast enough that the main miner loop runs
multiple times per second with the previous loop count. In each loop, a
thread generates a new block template, which requires grabbing cs_main
a couple times. I found this to be a significant source of contention,
often causing both SHA mining and wallet syncing to stop.

In contrast, a RandomX miner thread runs its main loop on the order of
minutes, with a lower loop count, and checks on every
hash attempt whether the tip has changed, resulting in approximately one
block template created per block.

I chose nMidLoopCount to approximately match the RandomX timing, while
nInnerLoopCount is still fast enough to be used as an intermittent
sub-second check of the chain height.

Author: Zannick

src/miner.cpp

@@ -869,6 +869,7 @@ void BitcoinMiner(std::shared_ptr<CReserveScript> coinbaseScript, bool fProofOfS
     enablewallet = !gArgs.GetBoolArg("-disablewallet", DEFAULT_DISABLE_WALLET);
 #endif
 
+    bool fBlockFoundAlready = false;
     while (!ShutdownRequested() && (GenerateActive() || (fProofOfStake && enablewallet)))
     {
         boost::this_thread::interruption_point();
@@ -985,6 +986,12 @@ void BitcoinMiner(std::shared_ptr<CReserveScript> coinbaseScript, bool fProofOfS
             IncrementExtraNonce(pblock, nHeight, nExtraNonce);
 
             int nTries = 0;
+            // As SHA runs much faster than the other algorithms, run more of them in this section
+            // to avoid lock contention from creating block templates. Use a separate counter
+            // nMidLoopCount to keep track of this, so that we can check every nInnerLoopCount hashes
+            // if the block is done.
+            int nMidTries = 0;
+            static const int nMidLoopCount = 0x1000;
             if (pblock->IsProgPow() && pblock->nTime >= Params().PowUpdateTimestamp()) {
                 uint256 mix_hash;
                 while (nTries < nInnerLoopCount &&
@@ -997,12 +1004,24 @@ void BitcoinMiner(std::shared_ptr<CReserveScript> coinbaseScript, bool fProofOfS
                 pblock->mixHash = mix_hash;
             } else if (pblock->IsSha256D() && pblock->nTime >= Params().PowUpdateTimestamp()) {
                 uint256 midStateHash = pblock->GetSha256dMidstate();
-                while (nTries < nInnerLoopCount &&
-                       !CheckProofOfWork(pblock->GetSha256D(midStateHash), pblock->nBits,
-                                         Params().GetConsensus(), CBlockHeader::SHA256D_BLOCK)) {
-                    boost::this_thread::interruption_point();
-                    ++nTries;
-                    ++pblock->nNonce64;
+                bool success = false;
+                while (nMidTries < nMidLoopCount) {
+                    while (nTries < nInnerLoopCount &&
+                           !(success = CheckProofOfWork(pblock->GetSha256D(midStateHash), pblock->nBits,
+                                   Params().GetConsensus(), CBlockHeader::SHA256D_BLOCK))) {
+                        boost::this_thread::interruption_point();
+                        ++nTries;
+                        ++pblock->nNonce64;
+                    }
+                    if (success) {
+                        break;
+                    }
+                    ++nMidTries;
+                    nTries = 0;
+                    if (pblock->nHeight <= chainActive.Height()) {
+                        fBlockFoundAlready = true;
+                        break;
+                    }
                 }
             } else if (pblock->nTime < Params().PowUpdateTimestamp()) {
                 while (nTries < nInnerLoopCount &&
@@ -1019,14 +1038,15 @@ void BitcoinMiner(std::shared_ptr<CReserveScript> coinbaseScript, bool fProofOfS
             double nHashSpeed = 0;
             {
                 LOCK(cs_nonce);
-                nHashes += nTries;
+                nHashes += nTries + (nMidTries * nInnerLoopCount);
                 nTimeDuration = GetTime() - nTimeStart;
                 if (!nTimeDuration) nTimeDuration = 1;
                 nHashSpeed = arith_uint256(nHashes/1000/nTimeDuration).getdouble();
             }
 
             LogPrint(BCLog::MINING, "%s: PoW Hashspeed %d kh/s\n", __func__,  nHashSpeed);
-            if (nTries == nInnerLoopCount) {
+            if (nMidTries == nMidLoopCount || fBlockFoundAlready) {
+                fBlockFoundAlready = false;
                 continue;
             }
         }