size thread pools by the cores we are allowed, not the ones the host has

std::thread::hardware_concurrency() reports the MACHINE's core count. Inside a
container that is the wrong number: with --cpuset-cpus 0-5 on a 12-core host it
still answers 12, and every caller that sized a pool from it oversubscribed 2x.

Measured on the pool box:
  - the pool node logged "Mining with 11 thread(s) of 12 core(s)" while
    confined to 6 CPUs
  - a burst miner launched with /hashthreads=2 filled the ~2 GB RandomX
    dataset with 12 threads, alongside the pool node in the same 8 GB container

AvailableCoreCount() asks sched_getaffinity what the cpuset actually permits,
which is the number all of these meant. It cannot make the dataset build slower:
the CPU budget is identical either way, so fewer threads on the same cores is
the same work without the thrash. Falls back to hardware_concurrency where the
call is unavailable, and never returns 0 because callers subtract from it.

Not the cause of the burst miner dying -- that was a corrupt Berkeley DB
environment in the worker datadir -- but it is why the failure landed on the
dataset build, and it is wrong on its own terms.

(cherry picked from commit b3bee16f3eef8982bff1174bd9d0a9c21473732c)

1 files changed, 35 insertions, 0 deletions

diff --git a/src/util.h b/src/util.h
index d95d3ae..d72518b 100644
--- a/src/util.h
+++ b/src/util.h
@@ -8,6 +8,13 @@
 #include <cxxabi.h>
 #endif
 
+// For AvailableCoreCount() below: sched_getaffinity on Linux, and
+// hardware_concurrency as the fallback everywhere else.
+#include <thread>
+#ifdef __linux__
+#include <sched.h>
+#endif
+
 #if defined(_MSC_VER) || defined(__BORLANDC__)
 typedef __int64  int64;
 typedef unsigned __int64  uint64;
@@ -144,6 +151,34 @@ int64 GetTime();
 int64 GetAdjustedTime();
 void AddTimeData(unsigned int ip, int64 nTime);
 
+// Cores this process is actually allowed to run on.
+//
+// std::thread::hardware_concurrency() reports the MACHINE's core count, which
+// is not the same number inside a container. With --cpuset-cpus 0-5 on a
+// 12-core host it still answers 12, so every caller that sized a thread pool
+// from it oversubscribed by 2x and then wondered why the box was thrashing:
+// the pool node started 11 miner threads on 6 permitted CPUs, and a burst
+// miner asked for 2 cores filled the ~2 GB RandomX dataset with 12 threads.
+//
+// sched_getaffinity reports what the cpuset permits, which is the number every
+// one of those callers meant. Falls back to hardware_concurrency where the
+// call is unavailable, and never returns 0 -- callers divide by this.
+inline unsigned int AvailableCoreCount()
+{
+#ifdef __linux__
+    cpu_set_t cpuset;
+    CPU_ZERO(&cpuset);
+    if (sched_getaffinity(0, sizeof(cpuset), &cpuset) == 0)
+    {
+        int nAllowed = CPU_COUNT(&cpuset);
+        if (nAllowed > 0)
+            return (unsigned int)nAllowed;
+    }
+#endif
+    unsigned int nCores = std::thread::hardware_concurrency();
+    return nCores > 0 ? nCores : 1;
+}
+