mine: one pool session in participant mode, not one per core

StartMinerThreads() sizes its pool with MinerThreadCount(), which is right for
solo mining -- each thread hashes a template of its own -- and wrong for
participant mode, where every thread entering BitcoinMiner() is a whole miner:
its own Stratum session, its own payout address off the rotation, its own pool
of /hashthreads workers. The two counts multiplied instead of dividing.

Measured on the pool box with /hashthreads=2: a container with no cpuset logged
"Mining with 11 thread(s) of 12 core(s)" -- 11 sessions, 22 hash threads on 12
cores, 1058% CPU, load 22.68 -- while the same binary under --cpuset-cpus 10,11
logged one session and 199%. The second miner (8 cores, /hashthreads=1) ran 7
sessions and went 74C to 89C. No code differed between those runs. Only the
cpuset did, which means the cpuset was holding the thread count down by
accident and every deployment without one was oversubscribed.

Participant mode now starts exactly one session, so /hashthreads means what it
says instead of being multiplied by the core count. The worker count moves to
ParticipantHashThreadCount(), next to MinerThreadCount() where the two are
easy to confuse, so what is printed at startup and what actually hashes cannot
drift apart -- and it IS printed now. It was only ever visible under -debug,
which is how eleven sessions ran unnoticed.

Same host, same cpuset (0-3), same arguments, measured as a delta over 20 s
more than four minutes after start:

  before  399% CPU, 6-7 threads hot, 3 sessions
  after   201% CPU, exactly 2 threads at 99.9%, 1 session

Solo mining is untouched: /gen without /participant still starts
MinerThreadCount() threads.

(cherry picked from commit 45bc9ed5bc132712092f3e7902fef746c6cae898)

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;
 }