clang-tools-extra/clangd/support/Threading.cpp

   1 //===--- Threading.cpp - Abstractions for multithreading ------------------===//
   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 #include "support/Threading.h"
  10 #include "support/Trace.h"
  11 #include "llvm/ADT/ScopeExit.h"
  12 #include "llvm/Support/Threading.h"
  13 #include "llvm/Support/thread.h"
  14 #include <atomic>
  15 #include <optional>
  16 #include <thread>
  17 #ifdef __USE_POSIX
  18 #include <pthread.h>
  19 #elif defined(__APPLE__)
  20 #include <sys/resource.h>
  21 #elif defined(_WIN32)
  22 #include <windows.h>
  23 #endif
  24
  25 namespace clang {
  26 namespace clangd {
  27
  28 void Notification::notify() {
  29   {
  30     std::lock_guard<std::mutex> Lock(Mu);
  31     Notified = true;
  32     // Broadcast with the lock held. This ensures that it's safe to destroy
  33     // a Notification after wait() returns, even from another thread.
  34     CV.notify_all();
  35   }
  36 }
  37
  38 bool Notification::wait(Deadline D) const {
  39   std::unique_lock<std::mutex> Lock(Mu);
  40   return clangd::wait(Lock, CV, D, [&] { return Notified; });
  41 }
  42
  43 Semaphore::Semaphore(std::size_t MaxLocks) : FreeSlots(MaxLocks) {}
  44
  45 bool Semaphore::try_lock() {
  46   std::unique_lock<std::mutex> Lock(Mutex);
  47   if (FreeSlots > 0) {
  48     --FreeSlots;
  49     return true;
  50   }
  51   return false;
  52 }
  53
  54 void Semaphore::lock() {
  55   trace::Span Span("WaitForFreeSemaphoreSlot");
  56   // trace::Span can also acquire locks in ctor and dtor, we make sure it
  57   // happens when Semaphore's own lock is not held.
  58   {
  59     std::unique_lock<std::mutex> Lock(Mutex);
  60     SlotsChanged.wait(Lock, [&]() { return FreeSlots > 0; });
  61     --FreeSlots;
  62   }
  63 }
  64
  65 void Semaphore::unlock() {
  66   std::unique_lock<std::mutex> Lock(Mutex);
  67   ++FreeSlots;
  68   Lock.unlock();
  69
  70   SlotsChanged.notify_one();
  71 }
  72
  73 AsyncTaskRunner::~AsyncTaskRunner() { wait(); }
  74
  75 bool AsyncTaskRunner::wait(Deadline D) const {
  76   std::unique_lock<std::mutex> Lock(Mutex);
  77   return clangd::wait(Lock, TasksReachedZero, D,
  78                       [&] { return InFlightTasks == 0; });
  79 }
  80
  81 void AsyncTaskRunner::runAsync(const llvm::Twine &Name,
  82                                llvm::unique_function<void()> Action) {
  83   {
  84     std::lock_guard<std::mutex> Lock(Mutex);
  85     ++InFlightTasks;
  86   }
  87
  88   auto CleanupTask = llvm::make_scope_exit([this]() {
  89     std::lock_guard<std::mutex> Lock(Mutex);
  90     int NewTasksCnt = --InFlightTasks;
  91     if (NewTasksCnt == 0) {
  92       // Note: we can't unlock here because we don't want the object to be
  93       // destroyed before we notify.
  94       TasksReachedZero.notify_one();
  95     }
  96   });
  97
  98   auto Task = [Name = Name.str(), Action = std::move(Action),
  99                Cleanup = std::move(CleanupTask)]() mutable {
 100     llvm::set_thread_name(Name);
 101     Action();
 102     // Make sure function stored by ThreadFunc is destroyed before Cleanup runs.
 103     Action = nullptr;
 104   };
 105
 106   // Ensure our worker threads have big enough stacks to run clang.
 107   llvm::thread Thread(
 108       /*clang::DesiredStackSize*/ std::optional<unsigned>(8 << 20),
 109       std::move(Task));
 110   Thread.detach();
 111 }
 112
 113 Deadline timeoutSeconds(std::optional<double> Seconds) {
 114   using namespace std::chrono;
 115   if (!Seconds)
 116     return Deadline::infinity();
 117   return steady_clock::now() +
 118          duration_cast<steady_clock::duration>(duration<double>(*Seconds));
 119 }
 120
 121 void wait(std::unique_lock<std::mutex> &Lock, std::condition_variable &CV,
 122           Deadline D) {
 123   if (D == Deadline::zero())
 124     return;
 125   if (D == Deadline::infinity())
 126     return CV.wait(Lock);
 127   CV.wait_until(Lock, D.time());
 128 }
 129
 130 bool PeriodicThrottler::operator()() {
 131   Rep Now = Stopwatch::now().time_since_epoch().count();
 132   Rep OldNext = Next.load(std::memory_order_acquire);
 133   if (Now < OldNext)
 134     return false;
 135   // We're ready to run (but may be racing other threads).
 136   // Work out the updated target time, and run if we successfully bump it.
 137   Rep NewNext = Now + Period;
 138   return Next.compare_exchange_strong(OldNext, NewNext,
 139                                       std::memory_order_acq_rel);
 140 }
 141
 142 } // namespace clangd
 143 } // namespace clang