[LLD] Make scoped timers thread safe

[rnk]

Summary

This is a pre-requisite to parallelizing PDB symbol and type merging.
Currently this timer usage would not be thread safe.

[MaskRay]

LGTM.

lld/COFF/Driver.cpp

if (auto *arg = args.getLastArg(OPT_linkrepro)) {
     sys::path::append(path, "repro.tar");
     return std::string(path);
   }
 
   return None;
 }
 
 void LinkerDriver::link(ArrayRef<const char *> argsArr) {
+  ScopedTimer rootTimer(Timer::root());
+
   // Needed for LTO.
   InitializeAllTargetInfos();
   InitializeAllTargets();
   InitializeAllTargetMCs();
   InitializeAllAsmParsers();
   InitializeAllAsmPrinters();
 
   // If the first command line argument is "/lib", link.exe acts like lib.exe.
if (auto *arg = args.getLastArg(OPT_threads)) {
     config->thinLTOJobs = v.str();
   }
 
   if (args.hasArg(OPT_show_timing))
     config->showTiming = true;
 
   config->showSummary = args.hasArg(OPT_summary);
 
-  ScopedTimer t(Timer::root());
   // Handle --version, which is an lld extension. This option is a bit odd
   // because it doesn't start with "/", but we deliberately chose "--" to
   // avoid conflict with /version and for compatibility with clang-cl.
   if (args.hasArg(OPT_dash_dash_version)) {
     lld::outs() << getLLDVersion() << "\n";
     return;
   }
 
if (config->doICF) {
     findKeepUniqueSections();
     doICF(symtab->getChunks());
   }
 
   // Write the result.
   writeResult();
 
   // Stop early so we can print the results.
-  Timer::root().stop();
+  rootTimer.stop();
   if (config->showTiming)
     Timer::root().print();
 }
 
 } // namespace coff
 } // namespace lld

lld/Common/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 "lld/Common/Timer.h"
 #include "lld/Common/ErrorHandler.h"
 #include "llvm/Support/Format.h"
 
 using namespace lld;
 using namespace llvm;
 
-ScopedTimer::ScopedTimer(Timer &t) : t(&t) { t.start(); }
+ScopedTimer::ScopedTimer(Timer &t) : t(&t) {
+  startTime = std::chrono::high_resolution_clock::now();
+}
 
 void ScopedTimer::stop() {
   if (!t)
     return;
-  t->stop();
+  t->addToTotal(std::chrono::high_resolution_clock::now() - startTime);
   t = nullptr;
 }
 
 ScopedTimer::~ScopedTimer() { stop(); }
 
-Timer::Timer(llvm::StringRef name) : name(std::string(name)), parent(nullptr) {}
-Timer::Timer(llvm::StringRef name, Timer &parent)
-    : name(std::string(name)), parent(&parent) {}
-
-void Timer::start() {
-  if (parent && total.count() == 0)
-    parent->children.push_back(this);
-  startTime = std::chrono::high_resolution_clock::now();
-}
-
-void Timer::stop() {
-  total += (std::chrono::high_resolution_clock::now() - startTime);
+Timer::Timer(llvm::StringRef name) : name(std::string(name)) {}
+Timer::Timer(llvm::StringRef name, Timer &parent) : name(std::string(name)) {
+  parent.children.push_back(this);
 }
 
 Timer &Timer::root() {
   static Timer rootTimer("Total Link Time");
   return rootTimer;
 }
 
 void Timer::print() {
   double totalDuration = static_cast<double>(root().millis());
 
   // We want to print the grand total under all the intermediate phases, so we
   // print all children first, then print the total under that.
   for (const auto &child : children)
+    if (child->total > 0)
       child->print(1, totalDuration);
 
   message(std::string(49, '-'));
 
   root().print(0, root().millis(), false);
 }
 
 double Timer::millis() const {
   return std::chrono::duration_cast<std::chrono::duration<double, std::milli>>(
-             total)
+             std::chrono::nanoseconds(total))
       .count();
 }
 
 void Timer::print(int depth, double totalDuration, bool recurse) const {
   double p = 100.0 * millis() / totalDuration;
 
   SmallString<32> str;
   llvm::raw_svector_ostream stream(str);
   std::string s = std::string(depth * 2, ' ') + name + std::string(":");
   stream << format("%-30s%5d ms (%5.1f%%)", s.c_str(), (int)millis(), p);
 
   message(str);
 
   if (recurse) {
     for (const auto &child : children)
+      if (child->total > 0)
         child->print(depth + 1, totalDuration);
   }
 }

lld/include/lld/Common/Timer.h

 //===- Timer.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 LLD_COMMON_TIMER_H
 #define LLD_COMMON_TIMER_H
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringRef.h"
 #include <assert.h>
+#include <atomic>
 #include <chrono>
 #include <map>
 #include <memory>
 
 namespace lld {
 
 class Timer;
 
 struct ScopedTimer {
   explicit ScopedTimer(Timer &t);
 
   ~ScopedTimer();
 
   void stop();
 
+  std::chrono::time_point<std::chrono::high_resolution_clock> startTime;
+
   Timer *t = nullptr;
 };
 
 class Timer {
 public:
   Timer(llvm::StringRef name, Timer &parent);
 
   static Timer &root();
 
-  void start();
-  void stop();
+  void addToTotal(std::chrono::nanoseconds time) { total += time.count(); }
   void print();
 
   double millis() const;
 
 private:
   explicit Timer(llvm::StringRef name);
   void print(int depth, double totalDuration, bool recurse = true) const;
 
-  std::chrono::time_point<std::chrono::high_resolution_clock> startTime;
-  std::chrono::nanoseconds total;
+  std::atomic<std::chrono::nanoseconds::rep> total;
   std::vector<Timer *> children;
   std::string name;
-  Timer *parent;
 };
 
 } // namespace lld
 
 #endif