blob: 46d413dc487b6820cd997636239698002f0136e1 [file] [log] [blame]
//===-- llvm/Support/Threading.h - Control multithreading mode --*- C++ -*-===//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// This file declares helper functions for running LLVM in a multi-threaded
// environment.
#include "llvm/ADT/SmallVector.h"
#include "llvm/Config/llvm-config.h" // for LLVM_ON_UNIX
#include "llvm/Support/Compiler.h"
#include <ciso646> // So we can check the C++ standard lib macros.
#include <functional>
#if defined(_MSC_VER)
// MSVC's call_once implementation worked since VS 2015, which is the minimum
// supported version as of this writing.
#elif defined(LLVM_ON_UNIX) && \
(defined(_LIBCPP_VERSION) || \
!(defined(__NetBSD__) || defined(__OpenBSD__) || \
(defined(__ppc__) || defined(__PPC__))))
// std::call_once from libc++ is used on all Unix platforms. Other
// implementations like libstdc++ are known to have problems on NetBSD,
// OpenBSD and PowerPC.
#elif defined(LLVM_ON_UNIX) && \
((defined(__ppc__) || defined(__PPC__)) && defined(__LITTLE_ENDIAN__))
#include <mutex>
#include "llvm/Support/Atomic.h"
namespace llvm {
class Twine;
/// Returns true if LLVM is compiled with support for multi-threading, and
/// false otherwise.
bool llvm_is_multithreaded();
/// llvm_execute_on_thread - Execute the given \p UserFn on a separate
/// thread, passing it the provided \p UserData and waits for thread
/// completion.
/// This function does not guarantee that the code will actually be executed
/// on a separate thread or honoring the requested stack size, but tries to do
/// so where system support is available.
/// \param UserFn - The callback to execute.
/// \param UserData - An argument to pass to the callback function.
/// \param RequestedStackSize - If non-zero, a requested size (in bytes) for
/// the thread stack.
void llvm_execute_on_thread(void (*UserFn)(void *), void *UserData,
unsigned RequestedStackSize = 0);
typedef std::once_flag once_flag;
enum InitStatus { Uninitialized = 0, Wait = 1, Done = 2 };
/// The llvm::once_flag structure
/// This type is modeled after std::once_flag to use with llvm::call_once.
/// This structure must be used as an opaque object. It is a struct to force
/// autoinitialization and behave like std::once_flag.
struct once_flag {
volatile sys::cas_flag status = Uninitialized;
/// Execute the function specified as a parameter once.
/// Typical usage:
/// \code
/// void foo() {...};
/// ...
/// static once_flag flag;
/// call_once(flag, foo);
/// \endcode
/// \param flag Flag used for tracking whether or not this has run.
/// \param F Function to call once.
template <typename Function, typename... Args>
void call_once(once_flag &flag, Function &&F, Args &&... ArgList) {
std::call_once(flag, std::forward<Function>(F),
// For other platforms we use a generic (if brittle) version based on our
// atomics.
sys::cas_flag old_val = sys::CompareAndSwap(&flag.status, Wait, Uninitialized);
if (old_val == Uninitialized) {
flag.status = Done;
} else {
// Wait until any thread doing the call has finished.
sys::cas_flag tmp = flag.status;
while (tmp != Done) {
tmp = flag.status;
/// Get the amount of currency to use for tasks requiring significant
/// memory or other resources. Currently based on physical cores, if
/// available for the host system, otherwise falls back to
/// thread::hardware_concurrency().
/// Returns 1 when LLVM is configured with LLVM_ENABLE_THREADS=OFF
unsigned heavyweight_hardware_concurrency();
/// Get the number of threads that the current program can execute
/// concurrently. On some systems std::thread::hardware_concurrency() returns
/// the total number of cores, without taking affinity into consideration.
/// Returns 1 when LLVM is configured with LLVM_ENABLE_THREADS=OFF.
/// Fallback to std::thread::hardware_concurrency() if sched_getaffinity is
/// not available.
unsigned hardware_concurrency();
/// Return the current thread id, as used in various OS system calls.
/// Note that not all platforms guarantee that the value returned will be
/// unique across the entire system, so portable code should not assume
/// this.
uint64_t get_threadid();
/// Get the maximum length of a thread name on this platform.
/// A value of 0 means there is no limit.
uint32_t get_max_thread_name_length();
/// Set the name of the current thread. Setting a thread's name can
/// be helpful for enabling useful diagnostics under a debugger or when
/// logging. The level of support for setting a thread's name varies
/// wildly across operating systems, and we only make a best effort to
/// perform the operation on supported platforms. No indication of success
/// or failure is returned.
void set_thread_name(const Twine &Name);
/// Get the name of the current thread. The level of support for
/// getting a thread's name varies wildly across operating systems, and it
/// is not even guaranteed that if you can successfully set a thread's name
/// that you can later get it back. This function is intended for diagnostic
/// purposes, and as with setting a thread's name no indication of whether
/// the operation succeeded or failed is returned.
void get_thread_name(SmallVectorImpl<char> &Name);
enum class ThreadPriority {
Background = 0,
Default = 1,
/// If priority is Background tries to lower current threads priority such
/// that it does not affect foreground tasks significantly. Can be used for
/// long-running, latency-insensitive tasks to make sure cpu is not hogged by
/// this task.
/// If the priority is default tries to restore current threads priority to
/// default scheduling priority.
enum class SetThreadPriorityResult { FAILURE, SUCCESS };
SetThreadPriorityResult set_thread_priority(ThreadPriority Priority);