DO NOT SUBMIT. [clangd] A helper Mutex class that reports contention stats

[ilya-biryukov]

Summary

Useful in getting some stats of a contention on a particular mutex.
Currently it only reports the sum of wall time taken by all threads
waiting on a mutex.

clangd/Threading.h

 //===--- ThreadPool.h --------------------------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_THREADING_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_THREADING_H
 
 #include "Context.h"
 #include "Function.h"
 #include "llvm/ADT/Twine.h"
+#include <atomic>
 #include <cassert>
+#include <chrono>
 #include <condition_variable>
 #include <memory>
 #include <mutex>
 #include <thread>
 #include <vector>
 
 namespace clang {
 namespace clangd {
public:
   void runAsync(const llvm::Twine &Name, llvm::unique_function<void()> Action);
 
 private:
   mutable std::mutex Mutex;
   mutable std::condition_variable TasksReachedZero;
   std::size_t InFlightTasks = 0;
 };
 
+class Mutex {
+public:
+  ~Mutex();
+
+  void lock();
+  void unlock();
+
+private:
+  std::mutex Mut;
+  std::chrono::steady_clock::duration WaitAllCPUs;
+};
+
 enum class ThreadPriority {
   Low = 0,
   Normal = 1,
 };
 void setCurrentThreadPriority(ThreadPriority Priority);
 // Avoid the use of scheduler policies that may starve low-priority threads.
 // This prevents tests from timing out on loaded systems.
 // Affects subsequent setThreadPriority() calls.
 void preventThreadStarvationInTests();
 
 } // namespace clangd
 } // namespace clang
 #endif

clangd/Threading.cpp

 #include "Threading.h"
+#include "Logger.h"
 #include "Trace.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/Threading.h"
 #include <atomic>
+#include <chrono>
 #include <thread>
 #ifdef __USE_POSIX
 #include <pthread.h>
 #endif
 
 using namespace llvm;
 namespace clang {
 namespace clangd {
pthread_setschedparam(
       Priority == ThreadPriority::Low && !AvoidThreadStarvation ? SCHED_IDLE
                                                                 : SCHED_OTHER,
       &priority);
 #endif
 }
 
 void preventThreadStarvationInTests() { AvoidThreadStarvation = true; }
 
+Mutex::~Mutex() {
+  log("Lock '{0}' was contended for {1} ms.", this,
+      std::chrono::duration_cast<std::chrono::milliseconds>(WaitAllCPUs).count());
+}
+
+void Mutex::lock() {
+  if (Mut.try_lock())
+    return;
+
+  auto Start = std::chrono::steady_clock::now();
+  Mut.lock();
+  WaitAllCPUs += std::chrono::steady_clock::now() - Start;
+}
+
+void Mutex::unlock() {
+  Mut.unlock();
+}
+
 } // namespace clangd
 } // namespace clang