[lldb] Ad os_signpost support to `lldb_private::Timer`

[JDevlieghere]

Summary

Emit os_signposts when supported from LLDB's timer class. A vast amount of performance sensitive places in LLDB are already instrumented with the Timer class. By emitting signposts we can examine this information in Instruments. I recommend looking at Daniel's differential for why this is so powerful: https://reviews.llvm.org/D52954.

[mib]

lldb/source/Utility/Timer.cpp

62

Did you mean startTimerInterval here ? I don't see startInterval in the llvm headers ...

89

Same here with llvm::SignpostEmitter::endTimerInterval

[JDevlieghere]

lldb/source/Utility/Timer.cpp

62

No, those are instances of llvm::Timer. If you look at the "Stack" you can see this depends on D93655 which changes the Signpost interface to work with arbitrary objects.

[mib]

Right! I thought it was depending on D52954 ... LGTM then !

lldb/include/lldb/Utility/Timer.h

 /// \class Timer Timer.h "lldb/Utility/Timer.h"
 /// A timer class that simplifies common timing metrics.
 
 class Timer {
 public:
   class Category {
   public:
     explicit Category(const char *category_name);
+    llvm::StringRef GetName() { return m_name; }
 
   private:
     friend class Timer;
     const char *m_name;
     std::atomic<uint64_t> m_nanos;
     std::atomic<uint64_t> m_nanos_total;
     std::atomic<uint64_t> m_count;
     std::atomic<Category *> m_next;

lldb/source/Utility/Timer.cpp

 //===-- Timer.cpp ---------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #include "lldb/Utility/Timer.h"
 #include "lldb/Utility/Stream.h"
+#include "llvm/Support/ManagedStatic.h"
+#include "llvm/Support/Signposts.h"
 
 #include <algorithm>
 #include <map>
 #include <mutex>
 #include <utility>
 #include <vector>
 
 #include <assert.h>
 #include <inttypes.h>
 #include <stdarg.h>
 #include <stdio.h>
 
 using namespace lldb_private;
 
 #define TIMER_INDENT_AMOUNT 2
 
 namespace {
 typedef std::vector<Timer *> TimerStack;
 static std::atomic<Timer::Category *> g_categories;
 } // end of anonymous namespace
 
+/// Allows llvm::Timer to emit signposts when supported.
+static llvm::ManagedStatic<llvm::SignpostEmitter> Signposts;
+
 std::atomic<bool> Timer::g_quiet(true);
 std::atomic<unsigned> Timer::g_display_depth(0);
 static std::mutex &GetFileMutex() {
   static std::mutex *g_file_mutex_ptr = new std::mutex();
   return *g_file_mutex_ptr;
 }
 
 static TimerStack &GetTimerStackForCurrentThread() {
do {
     m_next = expected;
   } while (!g_categories.compare_exchange_weak(expected, this));
 }
 
 void Timer::SetQuiet(bool value) { g_quiet = value; }
 
 Timer::Timer(Timer::Category &category, const char *format, ...)
     : m_category(category), m_total_start(std::chrono::steady_clock::now()) {
+  Signposts->startInterval(this, m_category.GetName());
   TimerStack &stack = GetTimerStackForCurrentThread();
 
   stack.push_back(this);
   if (g_quiet && stack.size() <= g_display_depth) {
     std::lock_guard<std::mutex> lock(GetFileMutex());
 
     // Indent
     ::fprintf(stdout, "%*s", int(stack.size() - 1) * TIMER_INDENT_AMOUNT, "");

 
 Timer::~Timer() {
   using namespace std::chrono;
 
   auto stop_time = steady_clock::now();
   auto total_dur = stop_time - m_total_start;
   auto timer_dur = total_dur - m_child_duration;
 
+  Signposts->endInterval(this, m_category.GetName());
+
   TimerStack &stack = GetTimerStackForCurrentThread();
   if (g_quiet && stack.size() <= g_display_depth) {
     std::lock_guard<std::mutex> lock(GetFileMutex());
     ::fprintf(stdout, "%*s%.9f sec (%.9f sec)\n",
               int(stack.size() - 1) * TIMER_INDENT_AMOUNT, "",
               duration<double>(total_dur).count(),
               duration<double>(timer_dur).count());
   }