3 files changed, 61 insertions, 11 deletions

diff --git a/src/main.cpp b/src/main.cpp
index efff96c..77aba89 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -170,6 +170,26 @@ int MinerThreadCount()
     return (int)(nCores - 1);
 }
 
+// Hash threads one participant session runs.
+//
+// Explicit /hashthreads=N is honored exactly, including 1 -- a miner who says
+// one means one. Automatic leaves a core to the node, the Stratum I/O loop and
+// everything else the process still has to do, for the same reason
+// MinerThreadCount() does.
+//
+// Lives here, next to that function, because the two are easy to confuse and
+// StartMinerThreads() needs to be able to tell them apart: only ONE session
+// runs in participant mode, and this is what sizes it.
+int ParticipantHashThreadCount()
+{
+    if (nHashThreads > 0)
+        return nHashThreads;
+    int nWorkers = (int)AvailableCoreCount();
+    if (nWorkers < 2)
+        nWorkers = 2;
+    return nWorkers - 1;
+}
+
 bool AddKey(const CKey& key)
 {
     if (IsWalletEncrypted())
@@ -3828,13 +3848,11 @@ connected:
     // shared dataset), then run the I/O loop below: receive pool messages,
     // publish jobs to the threads, submit the shares they find.
     // ------------------------------------------------------------------
-    int nWorkers = nHashThreads > 0 ? nHashThreads
-                                    : (int)AvailableCoreCount();
-    if (nHashThreads <= 0) {
-        if (nWorkers < 2) nWorkers = 2;
-        nWorkers -= 1; // leave one core for node + I/O threads
-    }
-    // explicit /hashthreads=N is honored exactly (including 1)
+    // One count, decided in one place (main.cpp:MinerThreadCount's neighbour),
+    // so that what StartMinerThreads() reports at startup and what actually
+    // hashes here can never drift apart. Explicit /hashthreads=N is honored
+    // exactly, including 1; automatic leaves one core for node + I/O threads.
+    int nWorkers = ParticipantHashThreadCount();
     ParticipantJobShared jobShared;
     std::vector<ParticipantShareHit> shareHits;
     std::mutex shareHitsMtx;
diff --git a/src/main.h b/src/main.h
index f5409e9..27f89ac 100644
--- a/src/main.h
+++ b/src/main.h
@@ -103,6 +103,9 @@ extern bool fSoloMineTest; // /solomine: mine without requiring a peer (local te
 extern int nMinerThreads;
 // Resolves the automatic case into a real count.
 int MinerThreadCount();
+// Hash threads one participant session runs; resolves /hashthreads. Not the
+// same number as MinerThreadCount(), and only ONE session ever runs.
+int ParticipantHashThreadCount();
 extern bool gPoolServerRunning;    // GUI/startup state
 extern volatile bool gPoolRunning; // runtime pool server loop flag (rpc.cpp)
 
diff --git a/src/net.cpp b/src/net.cpp
index e08f6f7..34c608c 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -1801,7 +1801,21 @@ void ThreadBitcoinMiner(void* parg)
 // Start the miners. Returns how many actually got off the ground.
 int StartMinerThreads()
 {
-    int nThreads = MinerThreadCount();
+    // MinerThreadCount() sizes the SOLO miner, where each thread hashes a
+    // template of its own and more threads is simply more hashrate.
+    //
+    // Participant mode is not that shape. Every thread that enters
+    // BitcoinMiner() takes the MINE_PARTICIPANT branch, and that branch is a
+    // whole miner: its own Stratum session to the pool, its own payout address
+    // from the rotation, and its own pool of /hashthreads worker threads. So
+    // the two counts multiply instead of dividing, and the machine ends up
+    // running MinerThreadCount() x nHashThreads hashing threads plus one pool
+    // connection each. On a 12-core host with /hashthreads=2 that is 11
+    // sessions and 22 hash threads -- roughly 2x the cores, which is not more
+    // work done, only more contention -- and with /hashthreads unset it is 11
+    // sessions of 11 workers. One session is the entirety of participant mode;
+    // /hashthreads is what sizes it, and it can then mean what it says.
+    int nThreads = (nMineMode == MINE_PARTICIPANT) ? 1 : MinerThreadCount();
     int nStarted = 0;
     for (int i = 0; i < nThreads; i++)
     {
@@ -1813,9 +1827,24 @@ int StartMinerThreads()
     // The dataset is one allocation shared by all of them; only the 2 MB
     // scratchpads multiply. Printed because "why is it using 2 GB" is the first
     // question anyone asks.
-    printf("Mining with %d thread(s) of %u core(s) -- about %d MB "
-           "(~2080 MB shared RandomX dataset + ~2 MB per thread)\n",
-           nStarted, AvailableCoreCount(), 2080 + 2 * nStarted);
+    //
+    // Participant mode reports the workers that session will run, not the one
+    // thread that runs it: the hash thread count is the number an operator
+    // watches, and it is the number that was wrong here. It is otherwise only
+    // logged under -debug, which is how 11 sessions ran unnoticed.
+    if (nMineMode == MINE_PARTICIPANT)
+    {
+        int nWorkers = ParticipantHashThreadCount();
+        printf("Mining for the pool with %d hash thread(s) of %u core(s) -- about %d MB "
+               "(~2080 MB shared RandomX dataset + ~2 MB per thread)\n",
+               nWorkers, AvailableCoreCount(), 2080 + 2 * nWorkers);
+    }
+    else
+    {
+        printf("Mining with %d thread(s) of %u core(s) -- about %d MB "
+               "(~2080 MB shared RandomX dataset + ~2 MB per thread)\n",
+               nStarted, AvailableCoreCount(), 2080 + 2 * nStarted);
+    }
     return nStarted;
 }