1 files changed, 147 insertions, 23 deletions

diff --git a/contrib/llvm-project/llvm/lib/Support/Unix/Threading.inc b/contrib/llvm-project/llvm/lib/Support/Unix/Threading.inc
index 99f64b4f553d..819748db4ec2 100644
--- a/contrib/llvm-project/llvm/lib/Support/Unix/Threading.inc
+++ b/contrib/llvm-project/llvm/lib/Support/Unix/Threading.inc
@@ -13,12 +13,18 @@
 #include "Unix.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/raw_ostream.h"
 
 #if defined(__APPLE__)
 #include <mach/mach_init.h>
 #include <mach/mach_port.h>
 #include <pthread/qos.h>
+#include <sys/sysctl.h>
+#include <sys/types.h>
 #endif
 
 #include <pthread.h>
@@ -52,7 +58,7 @@
 namespace llvm {
 pthread_t
 llvm_execute_on_thread_impl(void *(*ThreadFunc)(void *), void *Arg,
-                            llvm::Optional<unsigned> StackSizeInBytes) {
+                            std::optional<unsigned> StackSizeInBytes) {
   int errnum;
 
   // Construct the attributes object.
@@ -98,13 +104,9 @@ void llvm_thread_join_impl(pthread_t Thread) {
   }
 }
 
-pthread_t llvm_thread_get_id_impl(pthread_t Thread) {
-  return Thread;
-}
+pthread_t llvm_thread_get_id_impl(pthread_t Thread) { return Thread; }
 
-pthread_t llvm_thread_get_current_id_impl() {
-  return ::pthread_self();
-}
+pthread_t llvm_thread_get_current_id_impl() { return ::pthread_self(); }
 
 } // namespace llvm
 
@@ -131,7 +133,6 @@ uint64_t llvm::get_threadid() {
 #endif
 }
 
-
 static constexpr uint32_t get_max_thread_name_length_impl() {
 #if defined(__NetBSD__)
   return PTHREAD_MAX_NAMELEN_NP;
@@ -180,7 +181,7 @@ void llvm::set_thread_name(const Twine &Name) {
   ::pthread_set_name_np(::pthread_self(), NameStr.data());
 #elif defined(__NetBSD__)
   ::pthread_setname_np(::pthread_self(), "%s",
-    const_cast<char *>(NameStr.data()));
+                       const_cast<char *>(NameStr.data()));
 #elif defined(__APPLE__)
   ::pthread_setname_np(NameStr.data());
 #endif
@@ -196,8 +197,8 @@ void llvm::get_thread_name(SmallVectorImpl<char> &Name) {
   struct kinfo_proc *kp = nullptr, *nkp;
   size_t len = 0;
   int error;
-  int ctl[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PID | KERN_PROC_INC_THREAD,
-    (int)pid };
+  int ctl[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID | KERN_PROC_INC_THREAD,
+                (int)pid};
 
   while (1) {
     error = sysctl(ctl, 4, kp, &len, nullptr, 0);
@@ -240,7 +241,7 @@ void llvm::get_thread_name(SmallVectorImpl<char> &Name) {
 #elif defined(__linux__)
 #if HAVE_PTHREAD_GETNAME_NP
   constexpr uint32_t len = get_max_thread_name_length_impl();
-  char Buffer[len] = {'\0'};  // FIXME: working around MSan false positive.
+  char Buffer[len] = {'\0'}; // FIXME: working around MSan false positive.
   if (0 == ::pthread_getname_np(::pthread_self(), Buffer, len))
     Name.append(Buffer, Buffer + strlen(Buffer));
 #endif
@@ -267,18 +268,22 @@ SetThreadPriorityResult llvm::set_thread_priority(ThreadPriority Priority) {
 #elif defined(__APPLE__)
   // https://developer.apple.com/documentation/apple-silicon/tuning-your-code-s-performance-for-apple-silicon
   //
-  // Background - Applies to work that isn’t visible to the user and may take significant
-  // time to complete. Examples include indexing, backing up, or synchronizing data. This
-  // class emphasizes energy efficiency.
+  // Background - Applies to work that isn’t visible to the user and may take
+  // significant time to complete. Examples include indexing, backing up, or
+  // synchronizing data. This class emphasizes energy efficiency.
   //
-  // Utility - Applies to work that takes anywhere from a few seconds to a few minutes to
-  // complete. Examples include downloading a document or importing data. This class
-  // offers a balance between responsiveness, performance, and energy efficiency.
-  const auto qosClass = [&](){
+  // Utility - Applies to work that takes anywhere from a few seconds to a few
+  // minutes to complete. Examples include downloading a document or importing
+  // data. This class offers a balance between responsiveness, performance, and
+  // energy efficiency.
+  const auto qosClass = [&]() {
     switch (Priority) {
-      case ThreadPriority::Background: return QOS_CLASS_BACKGROUND;
-      case ThreadPriority::Low: return QOS_CLASS_UTILITY;
-      case ThreadPriority::Default: return QOS_CLASS_DEFAULT;
+    case ThreadPriority::Background:
+      return QOS_CLASS_BACKGROUND;
+    case ThreadPriority::Low:
+      return QOS_CLASS_UTILITY;
+    case ThreadPriority::Default:
+      return QOS_CLASS_DEFAULT;
     }
   }();
   return !pthread_set_qos_class_self_np(qosClass, 0)
@@ -290,7 +295,7 @@ SetThreadPriorityResult llvm::set_thread_priority(ThreadPriority Priority) {
 
 #include <thread>
 
-int computeHostNumHardwareThreads() {
+static int computeHostNumHardwareThreads() {
 #if defined(__FreeBSD__)
   cpuset_t mask;
   CPU_ZERO(&mask);
@@ -317,3 +322,122 @@ llvm::BitVector llvm::get_thread_affinity_mask() {
 }
 
 unsigned llvm::get_cpus() { return 1; }
+
+#if defined(__linux__) && (defined(__i386__) || defined(__x86_64__))
+// On Linux, the number of physical cores can be computed from /proc/cpuinfo,
+// using the number of unique physical/core id pairs. The following
+// implementation reads the /proc/cpuinfo format on an x86_64 system.
+static int computeHostNumPhysicalCores() {
+  // Enabled represents the number of physical id/core id pairs with at least
+  // one processor id enabled by the CPU affinity mask.
+  cpu_set_t Affinity, Enabled;
+  if (sched_getaffinity(0, sizeof(Affinity), &Affinity) != 0)
+    return -1;
+  CPU_ZERO(&Enabled);
+
+  // Read /proc/cpuinfo as a stream (until EOF reached). It cannot be
+  // mmapped because it appears to have 0 size.
+  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Text =
+      llvm::MemoryBuffer::getFileAsStream("/proc/cpuinfo");
+  if (std::error_code EC = Text.getError()) {
+    llvm::errs() << "Can't read "
+                 << "/proc/cpuinfo: " << EC.message() << "\n";
+    return -1;
+  }
+  SmallVector<StringRef, 8> strs;
+  (*Text)->getBuffer().split(strs, "\n", /*MaxSplit=*/-1,
+                             /*KeepEmpty=*/false);
+  int CurProcessor = -1;
+  int CurPhysicalId = -1;
+  int CurSiblings = -1;
+  int CurCoreId = -1;
+  for (StringRef Line : strs) {
+    std::pair<StringRef, StringRef> Data = Line.split(':');
+    auto Name = Data.first.trim();
+    auto Val = Data.second.trim();
+    // These fields are available if the kernel is configured with CONFIG_SMP.
+    if (Name == "processor")
+      Val.getAsInteger(10, CurProcessor);
+    else if (Name == "physical id")
+      Val.getAsInteger(10, CurPhysicalId);
+    else if (Name == "siblings")
+      Val.getAsInteger(10, CurSiblings);
+    else if (Name == "core id") {
+      Val.getAsInteger(10, CurCoreId);
+      // The processor id corresponds to an index into cpu_set_t.
+      if (CPU_ISSET(CurProcessor, &Affinity))
+        CPU_SET(CurPhysicalId * CurSiblings + CurCoreId, &Enabled);
+    }
+  }
+  return CPU_COUNT(&Enabled);
+}
+#elif defined(__linux__) && defined(__s390x__)
+static int computeHostNumPhysicalCores() {
+  return sysconf(_SC_NPROCESSORS_ONLN);
+}
+#elif defined(__linux__) && !defined(__ANDROID__)
+static int computeHostNumPhysicalCores() {
+  cpu_set_t Affinity;
+  if (sched_getaffinity(0, sizeof(Affinity), &Affinity) == 0)
+    return CPU_COUNT(&Affinity);
+
+  // The call to sched_getaffinity() may have failed because the Affinity
+  // mask is too small for the number of CPU's on the system (i.e. the
+  // system has more than 1024 CPUs). Allocate a mask large enough for
+  // twice as many CPUs.
+  cpu_set_t *DynAffinity;
+  DynAffinity = CPU_ALLOC(2048);
+  if (sched_getaffinity(0, CPU_ALLOC_SIZE(2048), DynAffinity) == 0) {
+    int NumCPUs = CPU_COUNT(DynAffinity);
+    CPU_FREE(DynAffinity);
+    return NumCPUs;
+  }
+  return -1;
+}
+#elif defined(__APPLE__)
+// Gets the number of *physical cores* on the machine.
+static int computeHostNumPhysicalCores() {
+  uint32_t count;
+  size_t len = sizeof(count);
+  sysctlbyname("hw.physicalcpu", &count, &len, NULL, 0);
+  if (count < 1) {
+    int nm[2];
+    nm[0] = CTL_HW;
+    nm[1] = HW_AVAILCPU;
+    sysctl(nm, 2, &count, &len, NULL, 0);
+    if (count < 1)
+      return -1;
+  }
+  return count;
+}
+#elif defined(__MVS__)
+static int computeHostNumPhysicalCores() {
+  enum {
+    // Byte offset of the pointer to the Communications Vector Table (CVT) in
+    // the Prefixed Save Area (PSA). The table entry is a 31-bit pointer and
+    // will be zero-extended to uintptr_t.
+    FLCCVT = 16,
+    // Byte offset of the pointer to the Common System Data Area (CSD) in the
+    // CVT. The table entry is a 31-bit pointer and will be zero-extended to
+    // uintptr_t.
+    CVTCSD = 660,
+    // Byte offset to the number of live CPs in the LPAR, stored as a signed
+    // 32-bit value in the table.
+    CSD_NUMBER_ONLINE_STANDARD_CPS = 264,
+  };
+  char *PSA = 0;
+  char *CVT = reinterpret_cast<char *>(
+      static_cast<uintptr_t>(reinterpret_cast<unsigned int &>(PSA[FLCCVT])));
+  char *CSD = reinterpret_cast<char *>(
+      static_cast<uintptr_t>(reinterpret_cast<unsigned int &>(CVT[CVTCSD])));
+  return reinterpret_cast<int &>(CSD[CSD_NUMBER_ONLINE_STANDARD_CPS]);
+}
+#else
+// On other systems, return -1 to indicate unknown.
+static int computeHostNumPhysicalCores() { return -1; }
+#endif
+
+int llvm::get_physical_cores() {
+  static int NumCores = computeHostNumPhysicalCores();
+  return NumCores;
+}