mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-24 19:52:54 +01:00
ae05eb086d
The goal of this patch is to maximize CPU utilization on multi-socket or high core count systems, so that parallel computations such as LLD/ThinLTO can use all hardware threads in the system. Before this patch, on Windows, a maximum of 64 hardware threads could be used at most, in some cases dispatched only on one CPU socket. == Background == Windows doesn't have a flat cpu_set_t like Linux. Instead, it projects hardware CPUs (or NUMA nodes) to applications through a concept of "processor groups". A "processor" is the smallest unit of execution on a CPU, that is, an hyper-thread if SMT is active; a core otherwise. There's a limit of 32-bit processors on older 32-bit versions of Windows, which later was raised to 64-processors with 64-bit versions of Windows. This limit comes from the affinity mask, which historically is represented by the sizeof(void*). Consequently, the concept of "processor groups" was introduced for dealing with systems with more than 64 hyper-threads. By default, the Windows OS assigns only one "processor group" to each starting application, in a round-robin manner. If the application wants to use more processors, it needs to programmatically enable it, by assigning threads to other "processor groups". This also means that affinity cannot cross "processor group" boundaries; one can only specify a "preferred" group on start-up, but the application is free to allocate more groups if it wants to. This creates a peculiar situation, where newer CPUs like the AMD EPYC 7702P (64-cores, 128-hyperthreads) are projected by the OS as two (2) "processor groups". This means that by default, an application can only use half of the cores. This situation could only get worse in the years to come, as dies with more cores will appear on the market. == The problem == The heavyweight_hardware_concurrency() API was introduced so that only *one hardware thread per core* was used. Once that API returns, that original intention is lost, only the number of threads is retained. Consider a situation, on Windows, where the system has 2 CPU sockets, 18 cores each, each core having 2 hyper-threads, for a total of 72 hyper-threads. Both heavyweight_hardware_concurrency() and hardware_concurrency() currently return 36, because on Windows they are simply wrappers over std:🧵:hardware_concurrency() -- which can only return processors from the current "processor group". == The changes in this patch == To solve this situation, we capture (and retain) the initial intention until the point of usage, through a new ThreadPoolStrategy class. The number of threads to use is deferred as late as possible, until the moment where the std::threads are created (ThreadPool in the case of ThinLTO). When using hardware_concurrency(), setting ThreadCount to 0 now means to use all the possible hardware CPU (SMT) threads. Providing a ThreadCount above to the maximum number of threads will have no effect, the maximum will be used instead. The heavyweight_hardware_concurrency() is similar to hardware_concurrency(), except that only one thread per hardware *core* will be used. When LLVM_ENABLE_THREADS is OFF, the threading APIs will always return 1, to ensure any caller loops will be exercised at least once. Differential Revision: https://reviews.llvm.org/D71775
82 lines
2.2 KiB
C++
82 lines
2.2 KiB
C++
//===- unittests/Threading.cpp - Thread tests -----------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Support/Threading.h"
|
|
#include "llvm/Support/thread.h"
|
|
#include "gtest/gtest.h"
|
|
|
|
#include <atomic>
|
|
#include <condition_variable>
|
|
|
|
using namespace llvm;
|
|
|
|
namespace {
|
|
|
|
TEST(Threading, PhysicalConcurrency) {
|
|
auto Num = heavyweight_hardware_concurrency();
|
|
// Since Num is unsigned this will also catch us trying to
|
|
// return -1.
|
|
ASSERT_LE(Num.compute_thread_count(),
|
|
hardware_concurrency().compute_thread_count());
|
|
}
|
|
|
|
#if LLVM_ENABLE_THREADS
|
|
|
|
class Notification {
|
|
public:
|
|
void notify() {
|
|
{
|
|
std::lock_guard<std::mutex> Lock(M);
|
|
Notified = true;
|
|
// Broadcast with the lock held, so it's safe to destroy the Notification
|
|
// after wait() returns.
|
|
CV.notify_all();
|
|
}
|
|
}
|
|
|
|
bool wait() {
|
|
std::unique_lock<std::mutex> Lock(M);
|
|
using steady_clock = std::chrono::steady_clock;
|
|
auto Deadline = steady_clock::now() +
|
|
std::chrono::duration_cast<steady_clock::duration>(
|
|
std::chrono::duration<double>(5));
|
|
return CV.wait_until(Lock, Deadline, [this] { return Notified; });
|
|
}
|
|
|
|
private:
|
|
bool Notified = false;
|
|
mutable std::condition_variable CV;
|
|
mutable std::mutex M;
|
|
};
|
|
|
|
TEST(Threading, RunOnThreadSyncAsync) {
|
|
Notification ThreadStarted, ThreadAdvanced, ThreadFinished;
|
|
|
|
auto ThreadFunc = [&] {
|
|
ThreadStarted.notify();
|
|
ASSERT_TRUE(ThreadAdvanced.wait());
|
|
ThreadFinished.notify();
|
|
};
|
|
|
|
llvm::llvm_execute_on_thread_async(ThreadFunc);
|
|
ASSERT_TRUE(ThreadStarted.wait());
|
|
ThreadAdvanced.notify();
|
|
ASSERT_TRUE(ThreadFinished.wait());
|
|
}
|
|
|
|
TEST(Threading, RunOnThreadSync) {
|
|
std::atomic_bool Executed(false);
|
|
llvm::llvm_execute_on_thread(
|
|
[](void *Arg) { *static_cast<std::atomic_bool *>(Arg) = true; },
|
|
&Executed);
|
|
ASSERT_EQ(Executed, true);
|
|
}
|
|
#endif
|
|
|
|
} // end anon namespace
|