!fixup update physical core detection code

Author: dmkozh

src/util/BatchExecutor.cpp

@@ -12,33 +12,63 @@
 #include <fstream>
 #include <pthread.h>
 #include <sched.h>
+#include <set>
 #endif
 
 namespace stellar
 {
 
 namespace
 {
-// Returns one logical CPU id per physical core: every CPU with the smallest id
-// among its thread-siblings. Empty on failure or on non-Linux platforms.
+// Returns one logical CPU id per physical core, restricted to the CPUs this
+// process is actually allowed to run on. Empty on failure or on non-Linux
+// platforms.
+//
+// The set of usable CPUs is discovered from the thread's affinity mask, not
+// assumed to be the contiguous range 0..hardware_concurrency()-1.
+// hardware_concurrency() is only a count, and the allowed set is commonly
+// sparse or non-zero-based (cgroup/cpuset confinement, taskset, or offlined
+// CPUs). Iterating by count would read topology for, and pin to, CPUs the
+// process cannot use - pthread_setaffinity_np then fails with EINVAL on every
+// worker even though usable physical cores exist.
 std::vector<unsigned>
 physicalCoreRepresentatives()
 {
     std::vector<unsigned> res;
 #ifdef __linux__
-    unsigned n = std::thread::hardware_concurrency();
-    for (unsigned cpu = 0; cpu < n; ++cpu)
+    cpu_set_t affinity;
+    CPU_ZERO(&affinity);
+    if (sched_getaffinity(0, sizeof(affinity), &affinity) != 0)
     {
+        // Affinity unavailable (e.g. more than CPU_SETSIZE logical CPUs); skip
+        // pinning rather than guess.
+        return {};
+    }
+
+    // Walk the allowed CPUs in ascending order and keep the first (hence
+    // smallest) allowed sibling of each physical core. thread_siblings_list
+    // begins with the smallest sibling id, which is a stable per-core
+    // identifier independent of the affinity mask, so it lets us collapse the
+    // logical CPUs of one core down to a single representative.
+    std::unordered_set<unsigned> seenCores;
+    for (unsigned cpu = 0; cpu < CPU_SETSIZE; ++cpu)
+    {
+        if (!CPU_ISSET(cpu, &affinity))
+        {
+            continue;
+        }
         std::ifstream in("/sys/devices/system/cpu/cpu" + std::to_string(cpu) +
                          "/topology/thread_siblings_list");
         // The list is formatted like "0,16" or "0-1"; the first (smallest)
-        // entry is the leading integer either way.
-        unsigned firstSibling;
-        if (!(in >> firstSibling))
+        // entry is the leading integer either way and identifies the core.
+        unsigned coreId;
+        if (!(in >> coreId))
         {
+            // Topology is unreadable for a CPU we are allowed to use, so skip
+            // pinning rather than guess.
             return {};
         }
-        if (firstSibling == cpu)
+        if (seenCores.insert(coreId).second)
         {
             res.push_back(cpu);
         }