} // namespace clang
namespace llvm {
-int get_physical_cores();
+namespace sys {
+
+int getHostNumPhysicalCores();
+
+} // namespace sys
} // namespace llvm
namespace {
/// \return - True on success.
bool getHostCPUFeatures(StringMap<bool, MallocAllocator> &Features);
+ /// Get the number of physical cores (as opposed to logical cores returned
+ /// from thread::hardware_concurrency(), which includes hyperthreads).
+ /// Returns -1 if unknown for the current host system.
+ int getHostNumPhysicalCores();
+
namespace detail {
/// Helper functions to extract HostCPUName from /proc/cpuinfo on linux.
StringRef getHostCPUNameForPowerPC(StringRef ProcCpuinfoContent);
/// Returns how many physical CPUs or NUMA groups the system has.
unsigned get_cpus();
- /// Returns how many physical cores (as opposed to logical cores returned from
- /// thread::hardware_concurrency(), which includes hyperthreads).
- /// Returns -1 if unknown for the current host system.
- int get_physical_cores();
-
enum class ThreadPriority {
/// Lower the current thread's priority as much as possible. Can be used
/// for long-running tasks that are not time critical; more energy-
} // namespace llvm
#endif
+#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]);
+}
+#elif defined(_WIN32) && LLVM_ENABLE_THREADS != 0
+// Defined in llvm/lib/Support/Windows/Threading.inc
+int computeHostNumPhysicalCores();
+#else
+// On other systems, return -1 to indicate unknown.
+static int computeHostNumPhysicalCores() { return -1; }
+#endif
+
+int sys::getHostNumPhysicalCores() {
+ static int NumCores = computeHostNumPhysicalCores();
+ return NumCores;
+}
+
#if defined(__i386__) || defined(_M_IX86) || \
defined(__x86_64__) || defined(_M_X64)
bool sys::getHostCPUFeatures(StringMap<bool> &Features) {
#include "llvm/Support/Threading.h"
#include "llvm/ADT/Optional.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringRef.h"
#include "llvm/Config/config.h"
-#include "llvm/Config/llvm-config.h"
-#include "llvm/Support/MemoryBuffer.h"
-#include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/Host.h"
#include <cassert>
#include <errno.h>
static int computeHostNumHardwareThreads();
unsigned llvm::ThreadPoolStrategy::compute_thread_count() const {
- int MaxThreadCount =
- UseHyperThreads ? computeHostNumHardwareThreads() : get_physical_cores();
+ int MaxThreadCount = UseHyperThreads ? computeHostNumHardwareThreads()
+ : sys::getHostNumPhysicalCores();
if (MaxThreadCount <= 0)
MaxThreadCount = 1;
if (ThreadsRequested == 0)
S.ThreadsRequested = V;
return S;
}
-
-#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]);
-}
-#elif defined(_WIN32) && LLVM_ENABLE_THREADS != 0
-// Defined in llvm/lib/Support/Windows/Threading.inc
-int computeHostNumPhysicalCores();
-#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;
-}
using namespace llvm;
+class HostTest : public testing::Test {
+ Triple Host;
+
+protected:
+ bool isSupportedArchAndOS() {
+ // Initially this is only testing detection of the number of
+ // physical cores, which is currently only supported/tested on
+ // some systems.
+ return (Host.isOSWindows() && llvm_is_multithreaded()) ||
+ Host.isOSDarwin() || (Host.isX86() && Host.isOSLinux()) ||
+ (Host.isOSLinux() && !Host.isAndroid()) ||
+ (Host.isSystemZ() && Host.isOSzOS());
+ }
+
+ HostTest() : Host(Triple::normalize(sys::getProcessTriple())) {}
+};
+
+TEST_F(HostTest, NumPhysicalCoresSupported) {
+ if (!isSupportedArchAndOS())
+ GTEST_SKIP();
+ int Num = sys::getHostNumPhysicalCores();
+ ASSERT_GT(Num, 0);
+}
+
+TEST_F(HostTest, NumPhysicalCoresUnsupported) {
+ if (isSupportedArchAndOS())
+ GTEST_SKIP();
+ int Num = sys::getHostNumPhysicalCores();
+ ASSERT_EQ(Num, -1);
+}
+
TEST(getLinuxHostCPUName, ARM) {
StringRef CortexA9ProcCpuinfo = R"(
processor : 0
return Success;
}
-TEST(HostTest, DummyRunAndGetCommandOutputUse) {
+TEST_F(HostTest, DummyRunAndGetCommandOutputUse) {
// Suppress defined-but-not-used warnings when the tests using the helper are
// disabled.
(void)&runAndGetCommandOutput;
}
-TEST(HostTest, getMacOSHostVersion) {
+TEST_F(HostTest, getMacOSHostVersion) {
llvm::Triple HostTriple(llvm::sys::getProcessTriple());
if (!HostTriple.isMacOSX())
GTEST_SKIP();
.getOSVersion();
}
-TEST(HostTest, AIXHostVersionDetect) {
+TEST_F(HostTest, AIXHostVersionDetect) {
llvm::Triple HostTriple(llvm::sys::getProcessTriple());
if (HostTriple.getOS() != Triple::AIX)
GTEST_SKIP();
ASSERT_EQ(SysMinor, HostVersion.getMinor());
}
-TEST(HostTest, AIXTargetVersionDetect) {
+TEST_F(HostTest, AIXTargetVersionDetect) {
llvm::Triple TargetTriple(llvm::sys::getDefaultTargetTriple());
if (TargetTriple.getOS() != Triple::AIX)
GTEST_SKIP();
ASSERT_EQ(SystemVersion.getMinor(), TargetVersion.getMinor());
}
-TEST(HostTest, AIXHostCPUDetect) {
+TEST_F(HostTest, AIXHostCPUDetect) {
llvm::Triple HostTriple(llvm::sys::getProcessTriple());
if (HostTriple.getOS() != Triple::AIX)
GTEST_SKIP();
//===----------------------------------------------------------------------===//
#include "llvm/Support/Threading.h"
-#include "llvm/ADT/Triple.h"
-#include "llvm/Support/Host.h"
#include "llvm/Support/thread.h"
#include "gtest/gtest.h"
namespace {
-static bool isThreadingSupportedArchAndOS() {
- Triple Host(Triple::normalize(sys::getProcessTriple()));
-
- // Initially this is only testing detection of the number of
- // physical cores, which is currently only supported/tested on
- // some systems.
- return (Host.isOSWindows() && llvm_is_multithreaded()) ||
- Host.isOSDarwin() || (Host.isX86() && Host.isOSLinux()) ||
- (Host.isOSLinux() && !Host.isAndroid()) ||
- (Host.isSystemZ() && Host.isOSzOS());
-}
-
TEST(Threading, PhysicalConcurrency) {
auto Num = heavyweight_hardware_concurrency();
// Since Num is unsigned this will also catch us trying to
hardware_concurrency().compute_thread_count());
}
-TEST(Threading, NumPhysicalCoresSupported) {
- if (!isThreadingSupportedArchAndOS())
- GTEST_SKIP();
- int Num = get_physical_cores();
- ASSERT_GT(Num, 0);
-}
-
-TEST(Threading, NumPhysicalCoresUnsupported) {
- if (isThreadingSupportedArchAndOS())
- GTEST_SKIP();
- int Num = get_physical_cores();
- ASSERT_EQ(Num, -1);
-}
-
#if LLVM_ENABLE_THREADS
class Notification {
projects / platform / upstream / llvm.git / commitdiff