include/llvm/Support/Threading.h

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