1//===-- llvm/Support/Threading.h - Control multithreading mode --*- C++ -*-===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file declares helper functions for running LLVM in a multi-threaded
11// environment.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_SUPPORT_THREADING_H
16#define LLVM_SUPPORT_THREADING_H
17
18#include "llvm/ADT/SmallVector.h"
19#include "llvm/Config/llvm-config.h" // for LLVM_ON_UNIX
20#include "llvm/Support/Compiler.h"
21#include <ciso646> // So we can check the C++ standard lib macros.
22#include <functional>
23
24#if defined(_MSC_VER)
25// MSVC's call_once implementation worked since VS 2015, which is the minimum
26// supported version as of this writing.
27#define LLVM_THREADING_USE_STD_CALL_ONCE 1
28#elif defined(LLVM_ON_UNIX) && \
29 (defined(_LIBCPP_VERSION) || \
30 !(defined(__NetBSD__) || defined(__OpenBSD__) || \
31 (defined(__ppc__) || defined(__PPC__))))
32// std::call_once from libc++ is used on all Unix platforms. Other
33// implementations like libstdc++ are known to have problems on NetBSD,
34// OpenBSD and PowerPC.
35#define LLVM_THREADING_USE_STD_CALL_ONCE 1
36#else
37#define LLVM_THREADING_USE_STD_CALL_ONCE 0
38#endif
39
40#if LLVM_THREADING_USE_STD_CALL_ONCE
41#include <mutex>
42#else
43#include "llvm/Support/Atomic.h"
44#endif
45
46namespace llvm {
47class Twine;
48
49/// Returns true if LLVM is compiled with support for multi-threading, and
50/// false otherwise.
51bool llvm_is_multithreaded();
52
53/// llvm_execute_on_thread - Execute the given \p UserFn on a separate
54/// thread, passing it the provided \p UserData and waits for thread
55/// completion.
56///
57/// This function does not guarantee that the code will actually be executed
58/// on a separate thread or honoring the requested stack size, but tries to do
59/// so where system support is available.
60///
61/// \param UserFn - The callback to execute.
62/// \param UserData - An argument to pass to the callback function.
63/// \param RequestedStackSize - If non-zero, a requested size (in bytes) for
64/// the thread stack.
65void llvm_execute_on_thread(void (*UserFn)(void *), void *UserData,
66 unsigned RequestedStackSize = 0);
67
68#if LLVM_THREADING_USE_STD_CALL_ONCE
69
70 typedef std::once_flag once_flag;
71
72#else
73
74 enum InitStatus { Uninitialized = 0, Wait = 1, Done = 2 };
75
76 /// The llvm::once_flag structure
77 ///
78 /// This type is modeled after std::once_flag to use with llvm::call_once.
79 /// This structure must be used as an opaque object. It is a struct to force
80 /// autoinitialization and behave like std::once_flag.
81 struct once_flag {
82 volatile sys::cas_flag status = Uninitialized;
83 };
84
85#endif
86
87 /// Execute the function specified as a parameter once.
88 ///
89 /// Typical usage:
90 /// \code
91 /// void foo() {...};
92 /// ...
93 /// static once_flag flag;
94 /// call_once(flag, foo);
95 /// \endcode
96 ///
97 /// \param flag Flag used for tracking whether or not this has run.
98 /// \param F Function to call once.
99 template <typename Function, typename... Args>
100 void call_once(once_flag &flag, Function &&F, Args &&... ArgList) {
101#if LLVM_THREADING_USE_STD_CALL_ONCE
102 std::call_once(flag, std::forward<Function>(F),
103 std::forward<Args>(ArgList)...);
104#else
105 // For other platforms we use a generic (if brittle) version based on our
106 // atomics.
107 sys::cas_flag old_val = sys::CompareAndSwap(&flag.status, Wait, Uninitialized);
108 if (old_val == Uninitialized) {
109 std::forward<Function>(F)(std::forward<Args>(ArgList)...);
110 sys::MemoryFence();
111 TsanIgnoreWritesBegin();
112 TsanHappensBefore(&flag.status);
113 flag.status = Done;
114 TsanIgnoreWritesEnd();
115 } else {
116 // Wait until any thread doing the call has finished.
117 sys::cas_flag tmp = flag.status;
118 sys::MemoryFence();
119 while (tmp != Done) {
120 tmp = flag.status;
121 sys::MemoryFence();
122 }
123 }
124 TsanHappensAfter(&flag.status);
125#endif
126 }
127
128 /// Get the amount of currency to use for tasks requiring significant
129 /// memory or other resources. Currently based on physical cores, if
130 /// available for the host system, otherwise falls back to
131 /// thread::hardware_concurrency().
132 /// Returns 1 when LLVM is configured with LLVM_ENABLE_THREADS=OFF
133 unsigned heavyweight_hardware_concurrency();
134
135 /// Get the number of threads that the current program can execute
136 /// concurrently. On some systems std::thread::hardware_concurrency() returns
137 /// the total number of cores, without taking affinity into consideration.
138 /// Returns 1 when LLVM is configured with LLVM_ENABLE_THREADS=OFF.
139 /// Fallback to std::thread::hardware_concurrency() if sched_getaffinity is
140 /// not available.
141 unsigned hardware_concurrency();
142
143 /// Return the current thread id, as used in various OS system calls.
144 /// Note that not all platforms guarantee that the value returned will be
145 /// unique across the entire system, so portable code should not assume
146 /// this.
147 uint64_t get_threadid();
148
149 /// Get the maximum length of a thread name on this platform.
150 /// A value of 0 means there is no limit.
151 uint32_t get_max_thread_name_length();
152
153 /// Set the name of the current thread. Setting a thread's name can
154 /// be helpful for enabling useful diagnostics under a debugger or when
155 /// logging. The level of support for setting a thread's name varies
156 /// wildly across operating systems, and we only make a best effort to
157 /// perform the operation on supported platforms. No indication of success
158 /// or failure is returned.
159 void set_thread_name(const Twine &Name);
160
161 /// Get the name of the current thread. The level of support for
162 /// getting a thread's name varies wildly across operating systems, and it
163 /// is not even guaranteed that if you can successfully set a thread's name
164 /// that you can later get it back. This function is intended for diagnostic
165 /// purposes, and as with setting a thread's name no indication of whether
166 /// the operation succeeded or failed is returned.
167 void get_thread_name(SmallVectorImpl<char> &Name);
168}
169
170#endif
171