[lldb] Move ownership of analytics out of Target

[JDevlieghere]

Summary

Move ownership of analytics out of Target and instead create a global Analytics singleton. This is necessary to allow LLDB to record metrics in contexts where a target either isn't available or doesn't make sense.
target).

lldb/include/lldb/Target/Target.h

protected:
   /// information of this target.
   lldb::TraceSP m_trace_sp;
   /// Stores the frame recognizers of this target.
   lldb::StackFrameRecognizerManagerUP m_frame_recognizer_manager_up;
 
   static void ImageSearchPathsChanged(const PathMappingList &path_list,
                                       void *baton);
 
-  // Utilities for `statistics` command.
-private:
-  Analytics m_analytics;
-
 public:
-  void SetCollectingStats(bool v) { m_analytics.SetEnabled(v); }
-
-  bool GetCollectingStats() { return m_analytics.IsEnabled(); }
-
-  Analytics &GetAnalytics() { return m_analytics; }
+  void SetCollectingStats(bool v) { GetAnalytics()->SetEnabled(v); }
+  bool GetCollectingStats() { return GetAnalytics()->IsEnabled(); }
 
 private:
   /// Construct with optional file and arch.
   ///
   /// This member is private. Clients must use
   /// TargetList::CreateTarget(const FileSpec*, const ArchSpec*)
   /// so all targets can be tracked from the central target list.
   ///

lldb/include/lldb/Utility/Analytics.h

 //===-- Analytics.h ---------------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_UTILITY_ANALYTICS_H
 #define LLDB_UTILITY_ANALYTICS_H
 
 #include "lldb/Utility/StructuredData.h"
 
+#include <mutex>
 #include <vector>
 
 namespace lldb_private {
 
 class Stream;
 
 /// A kind of metric to collect.
 enum class Metric : unsigned {
public:
   bool IsEnabled() const { return m_collecting_analytics; }
 
   void Record(Metric stat);
 
   void Print(Stream &stream) const;
 
   std::unique_ptr<StructuredData::Dictionary> GetAsStructuredData() const;
 
+  static void Initialize();
+  static void Terminate();
+
 private:
   std::vector<unsigned> m_counters;
   bool m_collecting_analytics = false;
 };
 
+/// RAII helper which acquires an exlusive lock on the global Analytics
+/// singleton on construction, and releases the lock on destruction.
+class ExclusivelyLockedAnalytics {
+public:
+  ExclusivelyLockedAnalytics();
+  ~ExclusivelyLockedAnalytics();
+
+  ExclusivelyLockedAnalytics(ExclusivelyLockedAnalytics &&) = default;
+
+  ExclusivelyLockedAnalytics &
+  operator=(ExclusivelyLockedAnalytics &&) = default;
+
+  Analytics *operator->() const;
+
+private:
+  std::unique_lock<std::mutex> m_guard;
+};
+
+/// Get a reference to the global Analytics singleton. This has UB when called
+/// without first calling \ref Analytics::Initialize.
+ExclusivelyLockedAnalytics GetAnalytics();
+
 } // namespace lldb_private
 
 #endif // LLDB_UTILITY_ANALYTICS_H

lldb/source/API/SBTarget.cpp

 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/TargetList.h"
+#include "lldb/Utility/Analytics.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/ProcessInfo.h"
 #include "lldb/Utility/RegularExpression.h"
 
 #include "Commands/CommandObjectBreakpoint.h"
 #include "lldb/Interpreter/CommandReturnObject.h"

 SBStructuredData SBTarget::GetStatistics() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBTarget, GetStatistics);
 
   SBStructuredData data;
   TargetSP target_sp(GetSP());
   if (!target_sp)
     return LLDB_RECORD_RESULT(data);
 
-  data.m_impl_up->SetObjectSP(target_sp->GetAnalytics().GetAsStructuredData());
+  data.m_impl_up->SetObjectSP(GetAnalytics()->GetAsStructuredData());
   return LLDB_RECORD_RESULT(data);
 }
 
 void SBTarget::SetCollectingStats(bool v) {
   LLDB_RECORD_METHOD(void, SBTarget, SetCollectingStats, (bool), v);
 
   TargetSP target_sp(GetSP());
   if (!target_sp)

lldb/source/API/SystemInitializerFull.cpp

llvm::Error SystemInitializerFull::Initialize() {
   // different thread later on which won't work (as the function isn't
   // thread-safe).
   const char *arg0 = "lldb";
   llvm::cl::ParseCommandLineOptions(1, &arg0);
 
 #define LLDB_PLUGIN(p) LLDB_PLUGIN_INITIALIZE(p);
 #include "Plugins/Plugins.def"
 
+  // Initialize analytics.
+  Analytics::Initialize();
+
   // Initialize plug-ins in core LLDB
   ProcessTrace::Initialize();
 
   // Scan for any system or user LLDB plug-ins
   PluginManager::Initialize();
 
   // The process settings need to know about installed plug-ins, so the
   // Settings must be initialized AFTER PluginManager::Initialize is called.
   Debugger::SettingsInitialize();
 
   return llvm::Error::success();
 }
 
 void SystemInitializerFull::Terminate() {
   Debugger::SettingsTerminate();
 
+  // Terminate analytics.
+  Analytics::Terminate();
+
   // Terminate plug-ins in core LLDB
   ProcessTrace::Terminate();
 
   // Terminate and unload and loaded system or user LLDB plug-ins
   PluginManager::Terminate();
 
 #define LLDB_PLUGIN(p) LLDB_PLUGIN_TERMINATE(p);
 #include "Plugins/Plugins.def"
 
   // Now shutdown the common parts, in reverse order.
   SystemInitializerCommon::Terminate();
 }

lldb/source/Commands/CommandObjectExpression.cpp

if (args.HasArgs()) {
     // No expression following options
     else if (expr.empty()) {
       GetMultilineExpression();
       return result.Succeeded();
     }
   }
 
   Target &target = GetSelectedOrDummyTarget();
-  Analytics &analytics = target.GetAnalytics();
   if (EvaluateExpression(expr, result.GetOutputStream(),
                          result.GetErrorStream(), result)) {
 
     if (!m_fixed_expression.empty() && target.GetEnableNotifyAboutFixIts()) {
       CommandHistory &history = m_interpreter.GetCommandHistory();
       // FIXME: Can we figure out what the user actually typed (e.g. some alias
       // for expr???)
       // If we can it would be nice to show that.
       std::string fixed_command("expression ");
       if (args.HasArgs()) {
         // Add in any options that might have been in the original command:
         fixed_command.append(std::string(args.GetArgStringWithDelimiter()));
         fixed_command.append(m_fixed_expression);
       } else
         fixed_command.append(m_fixed_expression);
       history.AppendString(fixed_command);
     }
-    analytics.Record(Metric::ExpressionSuccess);
+    GetAnalytics()->Record(Metric::ExpressionSuccess);
     return true;
   }
 
-  analytics.Record(Metric::ExpressionFailure);
+  GetAnalytics()->Record(Metric::ExpressionFailure);
   result.SetStatus(eReturnStatusFailed);
   return false;
 }

lldb/source/Commands/CommandObjectFrame.cpp

bool DoExecute(Args &command, CommandReturnObject &result) override {
     if (m_interpreter.TruncationWarningNecessary()) {
       result.GetOutputStream().Printf(m_interpreter.TruncationWarningText(),
                                       m_cmd_name.c_str());
       m_interpreter.TruncationWarningGiven();
     }
 
     // Increment statistics.
     bool res = result.Succeeded();
-    Target &target = GetSelectedOrDummyTarget();
-    Analytics &analytics = target.GetAnalytics();
-    analytics.Record(res ? Metric::FrameVarSuccess : Metric::FrameVarFailure);
+    GetAnalytics()->Record(res ? Metric::FrameVarSuccess
+                               : Metric::FrameVarFailure);
     return res;
   }
 
   OptionGroupOptions m_option_group;
   OptionGroupVariable m_option_variable;
   OptionGroupFormat m_option_format;
   OptionGroupValueObjectDisplay m_varobj_options;
 };

lldb/source/Commands/CommandObjectStats.cpp

CommandObjectStatsEnable(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "enable",
                             "Enable statistics collection", nullptr,
                             eCommandProcessMustBePaused) {}
 
   ~CommandObjectStatsEnable() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target &target = GetSelectedOrDummyTarget();
+    ExclusivelyLockedAnalytics analytics = GetAnalytics();
 
-    if (target.GetCollectingStats()) {
+    if (analytics->IsEnabled()) {
       result.AppendError("statistics already enabled");
       return false;
     }
 
-    target.SetCollectingStats(true);
+    analytics->SetEnabled(true);
     result.SetStatus(eReturnStatusSuccessFinishResult);
     return true;
   }
 };
 
 class CommandObjectStatsDisable : public CommandObjectParsed {
 public:
   CommandObjectStatsDisable(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "disable",
                             "Disable statistics collection", nullptr,
                             eCommandProcessMustBePaused) {}
 
   ~CommandObjectStatsDisable() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target &target = GetSelectedOrDummyTarget();
+    ExclusivelyLockedAnalytics analytics = GetAnalytics();
 
-    if (!target.GetCollectingStats()) {
+    if (!analytics->IsEnabled()) {
       result.AppendError("need to enable statistics before disabling them");
       return false;
     }
 
-    target.SetCollectingStats(false);
+    analytics->SetEnabled(false);
     result.SetStatus(eReturnStatusSuccessFinishResult);
     return true;
   }
 };
 
 class CommandObjectStatsDump : public CommandObjectParsed {
 public:
   CommandObjectStatsDump(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "dump", "Dump statistics results",
                             nullptr, eCommandProcessMustBePaused) {}
 
   ~CommandObjectStatsDump() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target &target = GetSelectedOrDummyTarget();
-    target.GetAnalytics().Print(result.GetOutputStream());
+    GetAnalytics()->Print(result.GetOutputStream());
     result.SetStatus(eReturnStatusSuccessFinishResult);
     return true;
   }
 };
 
 CommandObjectStats::CommandObjectStats(CommandInterpreter &interpreter)
     : CommandObjectMultiword(interpreter, "statistics",
                              "Print statistics about a debugging session",

lldb/source/Utility/Analytics.cpp

 #include "lldb/Utility/StructuredData.h"
 
 #include <cassert>
 #include <memory>
 #include <utility>
 
 namespace lldb_private {
 
+static std::unique_ptr<Analytics> g_analytics;
+static std::mutex g_analytics_lock;
+
 static unsigned GetNumberOfMetrics() {
   return static_cast<unsigned>(Metric::MaxID);
 }
 
 static unsigned GetCounterIndexForMetric(Metric S) {
   assert(S != Metric::MaxID && "invalid metric");
   return static_cast<unsigned>(S);
 }
Analytics::GetAsStructuredData() const {
   auto metrics_up = std::make_unique<StructuredData::Dictionary>();
   for (unsigned metric_id = 0; metric_id < GetNumberOfMetrics(); ++metric_id) {
     Metric s = GetMetricForCounterIndex(metric_id);
     metrics_up->AddIntegerItem(GetMetricDescription(s), m_counters[metric_id]);
   }
   return metrics_up;
 }
 
+void Analytics::Initialize() { g_analytics = std::make_unique<Analytics>(); }
+
+void Analytics::Terminate() { g_analytics.reset(); }
+
+ExclusivelyLockedAnalytics::ExclusivelyLockedAnalytics() {
+  m_guard = std::unique_lock<std::mutex>(g_analytics_lock);
+}
+
+ExclusivelyLockedAnalytics::~ExclusivelyLockedAnalytics() {}
+
+Analytics *ExclusivelyLockedAnalytics::operator->() const {
+  return g_analytics.get();
+}
+
+ExclusivelyLockedAnalytics GetAnalytics() {
+  return ExclusivelyLockedAnalytics();
+}
+
 } // namespace lldb_private